爪哇2博客
爪哇2博客

计算排序数组中每个元素的出现次数(或频率)

如果您想练习数据结构和算法程序,可以通过 100多种数据结构和算法程序.

在这篇文章中,我们将看到如何计算排序数组中每个元素的出现次数(或频率)


问题

给定包含重复项的整数排序数组。查找数组中每个唯一元素的频率。
频率 定义为数组中任何元素的出现次数。

例如 :

输入值:
整型 [] rr = {2,2,2,3,3,4,5,5,5,6,6};

输出量:
2的频率是:3
3的频率是:2
4的频率是:1
5的频率是:2
6的频率是:2


Lets first Discuss the basic divide and conquer strategy to solve this problem.
we divide the rray 整型o two halves every time our function is called splitting our problem 整型o half every time giving rise to a worst 时间复杂度 of O(log(n)).

我们的数组实际上并没有分成两半,但是我们保留了两个指针,它们的开始和结尾分别代表要使用的数组的某些部分,这就是我们对数组进行虚拟拆分的方式。

我们知道我们的数组已经排序。所以我们可以得出结论,

  • 如果 the 元件s at 开始 pointer and 结束 pointer are equal to the 元件 whose frequency is to be calculated, this means that whole virtual rray 包含 that 元件 only and hence we directly 加 (end-start+1) to our frequency count.
  • 如果不是这种情况,我们将对数组的两半进行递归处理,并以后顺序添加这两个结果的调用,以得出最终的频率计数结果。

现在,整个算法用于查找数组中一个元素的频率。
为了找到每个元素的频率,需要每次调用此函数。
因此整体最差 时间复杂度 用这个算法解决这个问题将是
O(n*log(n)).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
 
组织.Arpit.爪哇2blog;
 
进口 爪哇.实用程序.哈希集;
进口 爪哇.实用程序.扫描器;
 
上市 每个元素的频率 {
 
上市 静态的 虚空 主要([] args) {
 
扫描器 scn = 扫描器(系统.);
整型[] rr = 整型[scn.nextInt()];
 
对于 (整型 i = 0; i < rr.长度; i++) {
rr[i] = scn.nextInt();
}
 
哈希集<整数> 处理 = 哈希集();
对于 (整型 : rr) {
如果 (!处理.包含()) {
系统..打印(“频率” + + “是:” +
解决递归(0, rr.长度 - 1, rr, ));
处理.();
}
}
 
}
 
上市 静态的 整型 解决递归(整型 开始, 整型 结束, 整型[] rr, 整型 元件) {
/ *如果start大于n,我们需要返回,因为
          代表负大小的子数组。* /
如果 (开始 > 结束) {
返回 0;
}
 
/ *这表示虚拟子数组的大小为1,
*并且只有一个元素。 * /
如果 (开始 == 结束) {
/ *现在,如果此单个元素等于该元素
*我们发现谁的频率,
*然后它将为其总频率贡献一个
*在整个数组中。 * /
如果 (rr[开始] == 元件 && rr[结束] == 元件) {
返回 1;
} 其他 {
返回 0;
}
}
 
/ *如果虚拟子数组的大小大于1,
*并且开始和结束处的元素相等,
*这意味着整个数组包括
*仅该元素,作为数组
*我们正在处理的已经排序。* /
如果 (rr[开始] == 元件 && rr[结束] == 元件) {
返回 (结束 - 开始 + 1);
}
 
整型 = (开始 + 结束) / 2;
/ *调用左侧虚拟子数组* /
整型 leftResult = 解决递归(开始, , rr, 元件);
 
/ *调用右侧虚拟子数组。* /
整型 rightResult = 解决递归( + 1, 结束, rr, 元件);
 
/ *我们的结果将以后期顺序计算,
*将是左侧结果
*加上右边的总和。* /
返回 leftResult + rightResult;
}
}
 

高效的方法:

There is an iterative and even efficient approach also which solves the problem 在 single parse 在 linear time i.e. O(n).

我们可以做的是,我们保留一个频率阵列并遍历该阵列,每当我们找到任何一个元素时,我们都会进入该频率阵列,并在该频率阵列中该元素的先前频率加1。
循环结束后,我们剩下一个数组,该数组在每个索引处都显示原始数组中的频率。
效率最大的优点是’不一定需要对数组进行排序。

例如:
考虑一个阵列及其频率阵列,
整型[] rr = {5,4,3,2,4,3,2,5,5};
整型[] freqArr = {0,0,0,0,0,0};
循环结束后的频率数组看起来像
整型[] freqArr = {0,0,2,2,1,3};

In this frequency rray, at every i th 在 dex, the frequency of  i 在 actual rray is sitting.

到这个时候,我们已经知道这种方法的缺点,
是, 当输入数组包含负数或大于10 ^ 9的数字时,此方法将无效。
因为我们没有任何负索引,所以不可能有大小为10 ^ 9的数组。
因此,为了处理该问题,我们需要使用 哈希图 where we store the 元件-frequency pair as the key-value pair 在 hashmap.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
 
组织.Arpit.爪哇2blog;
 
进口 爪哇.实用程序.哈希图;
进口 爪哇.实用程序.哈希集;
进口 爪哇.实用程序.扫描器;
 
上市 每个元素的频率 {
 
上市 静态的 虚空 主要([] args) {
 
扫描器 scn = 扫描器(系统.);
整型[] rr = 整型[scn.nextInt()];
 
对于 (整型 i = 0; i < rr.长度; i++) {
rr[i] = scn.nextInt();
}
 
系统..打印(“ rr []:{”);
对于 (整型 i = 0; i < rr.长度; i++) {
系统..打印(+rr[i]);
}
 
系统..打印(“}”);
哈希图<整数, 整数> freqMap = 解决迭代(rr);
 
对于(整型 : freqMap.键集())
{
系统..打印(“频率” + + “是:” + freqMap.得到());
}
 
}
 
上市 静态的 哈希图<整数, 整数> 解决迭代(整型[] rr)
{
哈希图<整数, 整数> freqMap = 哈希图<>();
 
/ *遍历数组以贡献+1
*作为每次遇到该元素的频率。* /
对于(整型 : rr)
{
如果(!freqMap.包含Key())
{
/ *如果hashmap不包含该元素,
*这意味着这是第一次遇到该元素,
*因此,此元素的频率现在为1。* /
freqMap.(, 1);
}
其他 {
/ *如果hashmap包含此元素,
*因此现在其更新的频率将是其过去的频率+ 1。
* /
freqMap.(, freqMap.得到()+1);
}
}
返回 freqMap;
}
}
 

当您在程序上方运行时,将获得以下输出

8
4 3 2 2 3 4 4 5
rr []:{4 3 2 2 3 4 4 5}
2的频率是:2
3的频率是:2
4的频率是:3
5的频率是:1

如有任何疑问或编辑,请发表评论。快乐学习ðŸ™,


导入联系人

您可能还喜欢:

分享这个

相关文章

  • 11月29日

    超过100个Java编码面试问题

    我一直在发布有关各种主题的数据结构和编码面试问题,例如数组,队列,堆栈,二叉树,LinkedList,字符串,数字,ArrayList等。因此,我将合并一个Java编码面试问题列表以创建索引发布。每当我添加新的Java [时,我都会继续添加指向此帖子的链接[…]

  • 4月18日

    到达最后一个索引的最小跳转数

    如果您想练习数据结构和算法程序,可以阅读100多种数据结构和算法程序。在这篇文章中,我们将看到如何找到到达上一个索引的最小跳转数。问题给定一个正整数数组A(可能为零),每个索引表示[…]

  • 3月28日

    对0、1和2的数组进行排序

    如果您想练习数据结构和算法程序,可以阅读100多种数据结构和算法程序。在这篇文章中,我们将看到如何对0、1和2s的数组进行排序。我们已经看到了有关对数组中的0s和1s进行排序的文章。问题给定一个包含零的数组,[…]

  • 3月04

    通过跳转检查是否有可能到达给定数组的末尾

    如果您想练习数据结构和算法程序,可以阅读100多种数据结构和算法程序。问题给定一个以正整数为元素的数组,该数组指示可以从数组中任何位置进行跳转的最大长度。检查是否可以[…]

  • 2月17日

    检查数组元素是否连续

    如果您想练习数据结构和算法程序,可以阅读100多种数据结构和算法程序。在这篇文章中,我们将看到如何检查数组元素是否连续。问题给定一个数组,我们需要检查数组是否包含连续的元素。例如:输入:array [] = {5,3,4,[…]

  • 2月04日

    O(Sqrt(height))中的K元树的LCA

    如果您想练习数据结构和算法程序,可以阅读100多种数据结构和算法程序。在这篇文章中,我们将了解如何在O(Sqrt(height))中找到K元树的最低公共祖先。我们已经看到了如何在O(n)复杂度中找到n元树的LCA。给定[…]

发表评论

您的电子邮件地址不会被公开。 必需的地方已做标记 *

订阅我们的新闻

获取质量教程到您的收件箱。现在订阅。


让我们成为朋友

©2020 爪哇2博客