Question

我有两个输入数组X和Y.我想返回数组X的元素，它在数组Y中以最高频率出现。

这样做的天真方式要求对于数组X的每个元素x，我线性搜索数组Y的出现次数，然后返回具有最高频率的元素x。这是伪算法：

 max_frequency = 0
 max_x = -1             // -1 indicates no element found
 For each x in X
     frequency = 0
     For each y in Y
         if y == x
             frequency++
     End For
     If frequency > max_frequency
         max_frequency = frequency
         max_x = x
     End If
 End For
 return max_x

由于存在两个嵌套循环，因此该算法的时间复杂度为O（n ^ 2）。我可以在O（nlogn）或更快的时候这样做吗？

Answer 1

使用哈希表映射键进行计数。对于数组中的每个元素，请执行counts[element] = counts[element] + 1或您的语言等效项。

最后，循环遍历哈希表中的映射并找到最大值

Answer 2

或者，如果您可以拥有其他数据结构，则可以遍历数组Y，以便在哈希表中更新其频率。这需要O(N(Y)时间。然后步行X找出X中哪个元素具有最高频率。这需要O(N(X))时间。总体而言：线性时间，因为您必须在任何实现中至少查看一次X和Y的每个元素（编辑：严格来说，这不是真的所有案例/所有实现，如 jwpat7 指出的那样，尽管在最坏的情况下是正确的），你不能比这更快。

Answer 3

下面列出了常用算法的时间复杂度：

Algorithm     |   Best    |   Worst   |  Average
--------------+-----------+-----------+---------- 
MergeSort     | O(n lg n) | O(n lg n) | O(n lg n)  
InsertionSort |   O(n)    |  O(n^2)   |  O(n^2)  
QuickSort     | O(n lg n) |  O(n^2)   | O(n lg n)  
HeapSort      | O(n lg n) | O(n lg n) | O(n lg n)  
BinarySearch  |   O(1)    |  O(lg n)  |  O(lg n)

一般来说，当遍历列表以满足某个标准时，你实际上不能做比线性时间更好的事情。如果你需要对数组进行排序，我会说坚持使用Mergesort（非常可靠）来找到数组中频率最高的元素。

注意：这是假设您要使用排序算法。否则，如果允许使用任何数据结构，我将使用具有恒定查找时间的hashmap / hashtable类型结构。这样，您只需匹配密钥并更新频率键值对。希望这可以帮助。

Answer 4

第一步：对 X 和 Y 进行排序。假设它们的相应长度为 m 且 n ，则此步骤的复杂度为O(n log n) + O(m log m)。

第二步：计算 Y 中的每个 X _i ，并追踪到目前为止的最大数量。在排序的 Y 中搜索 X _i 为O(log n)。第二步复杂度为：O(m log n)

总复杂度：O(n log n) + O(m log m) + O(m log n)或简化：O(max(n,m) log n)

Answer 5

基于划分和征服概念的合并排序为您提供O（nlogn）复杂性

Answer 6

如果两个列表的长度为n，则建议的方法为O（n ^ 2）。更有可能的是列表的长度可以不同，因此时间复杂度可以表示为O（mn）。

您可以将问题分为两个阶段： 1.按Y的频率对Y中的唯一元素进行排序 2.找到此列表中存在于X

中的第一个项目

由于这听起来像是一个家庭作业问题，我会让你思考你可以多快地完成这些单独的步骤。这些成本的总和将为您提供算法的总体成本。有许多方法比您目前拥有的两个列表长度的产品便宜。

Answer 7

排序X和Y.然后进行合并排序。每次遇到X中的相同元素时，从Y计算频率。

如此复杂，O（nlogn）+ O（mlogm）+ O（m + n）= O（klogk）其中n，m = X，Y的长度; k = max（m，n）

Answer 8

可以执行快速排序，然后使用变量遍历它，该变量计算一行中有多少个数+该数字是多少。这应该给你nlogn

在阵列中找到频率最高的元素的最快算法是什么

8 个答案: