Algorithm 在log（n）time中查找排序数组中至少出现k次的元素

给定一个由n个元素和k个数字组成的排序数组，是否有可能找到一个在log（n）时间内出现k次以上的元素？如果有一个以上的数字出现超过k次，则可以接受其中任何一个

如果是，如何进行

编辑：

---

我能够在线性时间内解决这个问题，我很高兴在这里发布这个解决方案——但在n中解决它相当简单。但是，要使它在log（n）中工作，我完全被难住了，这就是我的问题所在。

不是一般的问题。例如，如果k=2，在最坏的情况下不检查数组的每个元素的算法都不能保证找到重复的元素。

一般来说不是。例如，如果k=2，在最坏的情况下不检查数组的每个元素的算法都不能保证找到重复的元素。

这里是

O（n/k log（k））

解决方案：

i = 0
while i+k-1 < n: //don't get out of bounds
   if arr[i] == arr[i+k-1]:
       produce arr[i] as dupe
       i = min { j | arr[j] > arr[i] } //binary search
   else:
       c = min { j | arr[j] == arr[i+k-1] } //binary search
       i = c

i=0
当i+k-1arr[i]}//二进制搜索
其他：
c=min{j|arr[j]==arr[i+k-1]}//二进制搜索
i=c

其思想是，检查索引

i+k-1

处的元素，如果它与索引

i

处的元素匹配-好，这是一个重复。否则，您不需要检查

i

到

i+k-1

之间的所有元素，只检查与

arr[i+k-1]

值相同的元素

您确实需要回过头来查找此元素的最早索引，但是您可以保证在下一次迭代中超过索引

i+k

，使此算法的总迭代次数

O（n/k）

，每次都需要

O（logk）

时间

这在渐进性上优于线性时间算法，尤其是对于

k

的大值（当

k

处于

O（n）

的情况下，算法衰减为

O（logn）

，例如，查找至少以0.1频率重复的元素）

这里是

O（n/k log（k））

解决方案：

i = 0
while i+k-1 < n: //don't get out of bounds
   if arr[i] == arr[i+k-1]:
       produce arr[i] as dupe
       i = min { j | arr[j] > arr[i] } //binary search
   else:
       c = min { j | arr[j] == arr[i+k-1] } //binary search
       i = c

i=0
当i+k-1arr[i]}//二进制搜索
其他：
c=min{j|arr[j]==arr[i+k-1]}//二进制搜索
i=c

其思想是，检查索引

i+k-1

处的元素，如果它与索引

i

处的元素匹配-好，这是一个重复。否则，您不需要检查

i

到

i+k-1

之间的所有元素，只检查与

arr[i+k-1]

值相同的元素

您确实需要回过头来查找此元素的最早索引，但是您可以保证在下一次迭代中超过索引

i+k

，使此算法的总迭代次数

O（n/k）

，每次都需要

O（logk）

时间

---

这在渐进性上优于线性时间算法，尤其是对于

k

的大值（对于

k

处于

O（n）

的情况，算法衰减为

O（logn）

，例如，查找至少以0.1频率重复的元素）

好问题。到目前为止你得到了什么？不是这样的。您至少需要提供您尝试过的内容。顺便说一下，如果

k

很大，线性解决方案也可以非常快，因为它只需要

n/k

元素检查。问得好。到目前为止你得到了什么？不是这样的。您至少需要提供您尝试过的内容。顺便说一句，如果

k

很大，线性解决方案也可以非常快，因为它只需要

n/k

元素检查。但是，给定一个元素

x

，您可以在

log（n）

时间中找出它是否在您的列表中至少有

k

个副本。但这是一个不同的问题。在给出特定参数的“最坏情况”性能时存在一个缺陷（复杂性可能取决于它）。这就像说BFS是O（V^2），因为E在O（V^2）中。这在技术上是正确的，但其复杂性更常见的表示法是O（V+E）。同样，为最差的

k

给出一个下界是愚蠢的，因为你可以根据

k

的值提供一个更好的解决方案。然而，给定一个元素

x

，你可以在

log（n）

时间内找出它在你的列表中是否至少有

k

个副本。但这是一个不同的问题。在给出特定参数的“最坏情况”性能时存在一个缺陷（复杂性可能取决于它）。这就像说BFS是O（V^2），因为E在O（V^2）中。这在技术上是正确的，但其复杂性更常见的表示法是O（V+E）。同样，为最坏的

k

给出一个下限是愚蠢的，因为你可以根据

k

的值提供更好的解决方案。回答得好@amit！回答得好@amit！