传说中百度的试题,用C#做二进制运算得到2.5亿数字中不重复数字数的O(n)算法

using System;
using System.IO;
using System.Collections;

namespace bucketSort
{
class Program
{
public const int maxCount = 25 * 1000 * 10000;//2.5亿不算大，还没超过整数范围呢
public const string FileName = @"c:/test.txt";

public static void Main(string[] args)
{

//写文件，用来实验的；写一遍就可以了；
//writeFile();
//Console.ReadLine();
//return;

FileStream FileReader = new FileStream(FileName, FileMode.Open);

//循环读入全部正个整数，每次读1个整数，产生1个bit,读到结尾标记就不读了；

int index = 0;
//创建两个够长的BitArray
//发现了.NET一个Bug,就是BitArray并不是可以按照int.MaxValue构造,所以限制了一下数字范围，期待微软能修改这个Bug。
//即使是在最大整数范围内，-2,147,483,648 到 2,147,483,647是4亿个Bit,1亿多字节， New这两个容器应该是2个100多M,在600M范围内。
//一个数组表示有没有这个数字

BitArray CountorSingle = new BitArray(250000000 + 1);

//第二个数组表示是否多次出现这个数字
BitArray CountorMore = new BitArray(250000000 + 1);

//循环检测，复杂度是O(N)
while (true)
{
byte[] tempByte = new byte[4];
index += FileReader.Read(tempByte, 0, 4);
int tempInt = System.BitConverter.ToInt32(tempByte, 0);

if (tempInt == -1)
{
break;
}
else
{
if (CountorSingle.Get(tempInt))
{
//出现多次,设置这个值，复杂度是O(1)
CountorMore.Set(tempInt, true);
}
else
{
////出现一次,设置这个值，复杂度是O(1)
CountorSingle.Set(tempInt, true);
}
}
}
FileReader.Close();

//从CountorSingle中排除CountorMore，采用逻辑Xor运算，复杂度是O(n)
//Xor运算如果两者值相同，为False,1,0=1 ; 0,1=1 ; 1,1=0 ; 0,0=0 前边已经排除了0,1的可能性。
CountorSingle = CountorSingle.Xor(CountorMore);//复杂度是O(n)
//再读负数那个文件。

//关键时刻到来了
int sum = 0;

//复杂度是O(n)
foreach (bool isExists in CountorSingle)
{
if (isExists)
{
sum++;
}
}

Console.WriteLine("全部计算复杂度是O(n)，结果是：" + sum);
Console.ReadLine();
//几分钟后，看到屏幕上显示：全部计算复杂度是O(n)，结果是：91836109

}
public static long getIndex(int x)
{
//int.MinValue的下标位于0，负整数n的下标是0-(long)int.MinValue；
//0的下标位于1-(long)int.MinValue,正整数n的下标是n+1-(long)int.MinValue；
if (x >= 0)
{
return (x + 1 - (long)int.MinValue) / 4;
}
else
{
return (0 - x) / 4;
}
}
public static void writeFile()
{
//写文件，用来实验的；写一遍就可以了，正数和零写到正数文件里，负数写到负数文件里。
//写2个文件是因为.NET的BitArray类只有构造函数是int的，如果都写一起，那么就超出了处理范围。

FileStream FileWriter = new FileStream(FileName, FileMode.OpenOrCreate);

System.Random rand = new Random();
int i = 0;
for (; i < maxCount; i++)
{
//写入2.5亿个整数，一个整数是4个Byte[],随机在250000000范围内；
//发现了.NET一个Bug,就是BitArray并不是可以按照int.MaxValue构造。
//所以就只好限制在250000000内了，先只考虑正数和0，
//负数可以另外改一下，放另外文件里计算。
int tempInt = rand.Next(0, 250000000);
FileWriter.Write(System.BitConverter.GetBytes(tempInt), 0, 4);

}
//结尾写一个-1做标记。
FileWriter.Write(System.BitConverter.GetBytes(-1), 0, 4);
FileWriter.Close();
//靠，970多兆的文件。实验完赶紧删除。
Console.WriteLine("写文件完毕！");
}

}
}