如何找到在数组中出现超过 n/k 次的所有值？

Question

我在 Coursera 上攻读 Algorithms, Part I 课程，其中一个面试问题（未评分）如下：

十进制占优。给定一个有 n 个键的数组，设计一个算法来找出所有出现超过 n/10 次的值。预期的 算法的运行时间应该是线性的。

它有一个提示：

使用快速选择确定第 (n/10) 个最大的键并检查它是否 出现 n/10 次以上。

我不明白 n/10 最大键与 n/10 重复值有什么关系。它不会告诉我哪些值出现的次数超过 n/10 次。

有一个paper 为 n/k 找到了更通用的解决方案，但我很难理解论文中的代码。

解决此问题的一种方法是对输入数组进行排序，然后再计算每个不同值的出现次数。这将花费 O(nlogn) + O(n) 时间，这比问题所要求的要多。

想法？

Answer 1

使用 QuickSelect 查找第 n/10 个最大的键（即，如果数组已排序，则该键将位于位置 n/10）需要线性时间。如果这个键的副本少于 n/10，那么你知道它上面的任何东西按排序顺序都没有 n/10 个副本，因为在排序的键上面没有任何 n/10 个副本的空间命令。如果有 n/10 或更多副本，那么您已经找到了出现超过 n/10 次的东西，并且再一次不可能有任何比它更大的东西出现超过 n/10 次，因为没有空间为它。

现在您有一个最多包含 9n/10 个值的数组，该值比您刚刚从 QuickSelect 中找到的键小。使用另一遍 QuickSelect 从这个剩余数组的顶部找到键 n/10。和以前一样，您可能会找到一个出现 n/10 次或更多次的键，无论您是否这样做，您都会从数组中删除至少 n/10 个条目。

因此，您可以通过 10 次 QuickSelect 调用来搜索整个数组，每次调用都需要线性时间。 10 是问题定义中固定的数字，因此整个操作仅计为线性时间。

Answer 2

Boyer-Moore Voting 算法有一个变体，它可以在O(nk) 中运行的输入中找到超过n/k 出现的所有元素，并且由于k = 10 对于您的问题，我认为它应该在@ 中运行987654326@时间。

来自here

以下是一个有趣的 O(nk) 解决方案：我们可以解决上述问题 在 O(nk) 时间内使用 O(k-1) 额外空间的问题。请注意，可以 输出中永远不会超过 k-1 个元素（为什么？）。主要有 该算法的三个步骤。

1) 创建一个大小为 (k-1) 的临时数组来存储元素及其 计数（输出元素将在这些 k-1 个元素中）。 以下是临时数组元素的结构。

 struct eleCount {
     int element;
     int count; };  
 struct eleCount temp[];  This step takes O(k) time.

2) 遍历输入数组并更新 temp[]（添加/删除一个 每个遍历的元素的元素或增加/减少计数）。这 数组 temp[] 在每一步存储潜在的 (k-1) 个候选对象。这 步骤需要 O(nk) 时间。

3) 遍历最终的 (k-1) 个潜在候选人（存储在 温度 [])。或每个元素，检查它是否实际计数超过 n/k。这一步需要 O(nk) 时间。

主要步骤是第 2 步，如何在 每一点？第 2 步中使用的步骤类似于著名的游戏：俄罗斯方块。我们 将每个数字视为俄罗斯方块中的一块，它在我们的 临时数组 temp[]。我们的任务是尽量保持相同的数字 堆叠在同一列上（临时数组中的计数递增）。

考虑 k = 4, n = 9 给定数组：3 1 2 2 2 1 4 3 3

i = 0

     3 _ _ temp[] has one element, 3 with count 1

i = 1

     3 1 _ temp[] has two elements, 3 and 1 with  counts 1 and 1 respectively

i = 2

     3 1 2 temp[] has three elements, 3, 1 and 2 with counts as 1, 1 and 1 respectively.

i = 3

     - - 2 
     3 1 2 temp[] has three elements, 3, 1 and 2 with counts as 1, 1 and 2 respectively.

i = 4

     - - 2 
     - - 2 
     3 1 2 temp[] has three elements, 3, 1 and 2 with counts as 1, 1 and 3 respectively.

i = 5

     - - 2 
     - 1 2 
     3 1 2 temp[] has three elements, 3, 1 and 2 with counts as 1, 2 and 3 respectively.  

现在问题来了，当 temp[] 已满，我们看到一个新元素——我们从 元素堆栈，即我们将每个元素的计数减少 1 in 温度[]。我们忽略当前元素。

i = 6

     - - 2 
     - 1 2  temp[] has two elements, 1 and 2 with counts as 1 and 2 respectively.

i = 7

       - 2 
     3 1 2  temp[] has three elements, 3, 1 and 2 with counts as 1, 1 and 2 respectively.

i = 8

     3 - 2
     3 1 2  temp[] has three elements, 3, 1 and 2 with counts as 2, 1 and 2 respectively. 

最后，我们最多有 k-1 个数字 温度[]。 temp 中的元素是 {3, 1, 2}。请注意，计数 temp[] 现在没用了，只在步骤 2 中需要计数。现在我们 需要检查 temp[] 中元素的实际数量是否更多 是否超过 n/k (9/4)。元素 3 和 2 的计数超过 9/4。 所以我们打印 3 和 2。

有关此方法的正确证明，请查看this answer from cs.stackexchange

Answer 3

你是对的。

QuickSelect 之后的下一个候选是十进制占优：n/10、2*n/10..9*n/10，因此仅检查 n/10 索引是不够的

请注意，在排序数组中占主导地位的元素占据了很长时间，并且肯定至少有一个具有提到索引的元素属于该运行。

k = 3, N = 11 的例子。设元素 b 至少占据数组的 1/3。在这种情况下，排序数组可能看起来像

b b b b * * * * * * * 
* b b b b * * * * * * 
* * b b b b * * * * *     
* * * b b b b * * * *     
* * * * b b b b * * *
* * * * * b b b b * *
* * * * * b b b b * *
* * * * * * b b b b *
* * * * * * * b b b b
      ^       ^       //positions for quickselect

请注意，在任何情况下，主导元素（如果确实存在 k 主导元素）至少占据一个标记位置。所以经过两轮 QuickSelect 我们有两个候选人

Answer 4

说实话，我在这里没有得到任何答案，但他们给出了如何解决问题的想法。根据前面提到的@MBo 的回答，您对每 10 个元素使用快速选择，但您使用的不是简单的快速选择，而是基于 3 路快速排序的快速选择。您不仅将每 10 个元素放置在它的位置上，而且将所有与其相等的元素放置在它的位置上。 并且经过一次迭代就足以计算出所有重复次数超过 9 个的元素。

Answer 5

我用 Dijkstra 解决 DNF 问题的方法决定了这个问题。 请参阅下面的我的实施。可能对某人感兴趣和有用。

public void dCount(Comparable[] arr) {
    dCount(arr, 0, arr.length - 1);
}
private void dCount(Comparable[] arr, int lo, int hi) {
    if (lo >= hi) return;
    int curr = lo;
    int lt = lo;
    int rt = hi;
    Comparable pivot = arr[lo];

    while (curr <= rt) { // 3-way qSort main cycle
        if (less(arr[curr], pivot))
            swap(arr, curr++, lt++);
        else if (less(pivot, arr[curr]))
            swap(arr, curr, rt--);
        else curr++;
    }
    int count = curr - lt;
    if (count > arr.length / 10) { // you can change count value if it needs (n / 3, n / 2... just change 10 to your number)           
        System.out.printf("%s repeats %d times\n", arr[lt], count);
    }
    dCount(arr, lo, lt -1); // recur call for the left side from the pivot equal range
    dCount(arr, rt + 1, hi); // recur call for the right side from the pivot equal range
}
private static boolean less(Comparable a, Comparable b) {
    return a.compareTo(b) < 0;
}
private static void swap(Comparable[] arr, int i, int j) {
    Comparable swap = arr[i];
    arr[i] = arr[j];
    arr[j] = swap;
}