给定一个包含 43 亿个 32 位整数的文件，我们如何找到一个至少出现两次的数字？

Question

我为此提出了分而治之的算法。只是想知道这是否可行？

第一个 mid 是从整数范围即 (0+(1>1 计算出来的，然后应用这个想法：从 start 到 mid 或从 mid 到 end 的数字范围总是小于比我们在考虑十亿数字时要考虑的数字，并且肯定会有一些数字会重复，因为与十亿数字相比，32 位整数的范围要小得多。

def get_duplicate(input, start, end):  
  while True:
    mid = (start >> 1) + end - (end >> 1)
    less_to_mid = 0
    more_to_mid = 0
    equal_to_mid = 0
    for data in input:
        data = int(data, 16)
        if data < mid:
            less_to_mid += 1
        elif data == mid:
            equal_to_mid += 1
        else:
            more_to_mid += 1
    if equal_to_mid > 1:
        return mid
    elif mid-start < less_to_mid:
        end = mid-1
    elif end-mid < more_to_mid:
        start = mid+1

with open("codes\output.txt", 'r+') as f:
  content = f.read().split()
  print(get_duplicate(content, 0, 1<<32-1))

我知道我们可以使用位数组，但我只是想了解您对此解决方案的看法，以及实施是否存在问题。

Answer 1

你的方法没问题。但您可能需要多次阅读输入内容才能找到答案。

这里有一个变种，它可以让你找到一个内存很少的重复项，但你只需要读取输入两次。

1. 将整数数组A[65536] 初始化为零。
2. 一一读出数字。每次读取一个数字x，将1 添加到A[x mod 65536]。
3. 读取结束时，至少有一个i，使得A[i]严格大于65536。这是因为65536 * 63356 < 4.3 billion。假设A[i0] 大于65536。
4. 将数组A清零。
5. 再读一遍数字，但这一次，只看那些数字x，这样x mod 65536 = i0。对于每个这样的x，将1 添加到A[x / 65536]。
6. 读取结束时，至少有一个j，使得A[j]严格大于1。那么65536 * j + i0这个数字就是最终的答案。

Answer 2

2^32 位内存对于现代系统来说没什么特别的。所以你必须使用bitset，这个数据结构每个数字只需要一个位，所有现代语言都有一个实现。想法是这样的——你只要记住一个数字是否已经被看到：

void print_twice_seen (Iterator &it)//iterates through all numbers
{
  std::bitset< (1L<<32) > seen;//bitset for 2^32 elements, assume 64bit system

  while(it.hasNext()){
       unsigned int val=it.next();//return current element and move the iterator
       if(seen[val])
           std::cout<<"Seen at least twice: "<<val<<std::endl;
       else
           seen.set(val, true);//remember as seen
  }
}