bitmap对海量无重复的整数排序--转

原文地址：http://blog.csdn.net/u013074465/article/details/46956295

现在有n个无重复的正整数（n 小于10的7次方），如果内存限制在1.5M以内，要求对着n个数进行排序。【编程珠玑第一章题目】

       很显然，10的7次方个整数占用的空间为10 ^ 7 * 4字节，大约等于40M，而内存限制为1.5M，因此，无法将所有数字加载到内存，所以快速排序、堆排序等高效的排序算法就没法使用。这里可以使用bitmap方式，用1bit表示一个整数，那么，10^7个整数需要10^7位，也就是大约1.25M空间。

如下是bitmap对无重复整数的排序过程。

 

一、一次bitmap就可以将所有数据排完

如果每个整数占一位，可以将所有的整数在内存中表示（如上述提到的那样），那么可以直接一次bitmap排序就完成了，时间复杂度为O(n)，空间复杂度为O(n位)。下面分别给出C和C++的bitset方式：

1、C语言方式

       下面代码以n = 100为例子；n是海量时，只要每个整数1bit可以一次在内存中表示所有整数的情况下，方法一样，将宏定义N的值改为海量数据的上限（比如10^7）即可：

[cpp]  view plain  copy

 

1. //位图排序  
2. #include <iostream>  
3. #include <bitset>  
4. #define WIDTHWORD 32 //一个整数的宽度是32bit  
5. #define SHIFT 5        
6. #define MASK 0x1F    //0x1f == 31  
7. #define N 100        //对十万个无重复的整数排序  
8. using namespace std;  
9.   
10. //申请一个N位的bitmap  
11. int bitmap[1 + N / WIDTHWORD];  
12.   
13. //将bitmap的第value设置为1  
14. void set(int value) {  
15.     bitmap[value >> SHIFT] |= (1 << (value & MASK));  
16. }  
17.   
18. //清除bitmap第value位上的1:设置为0  
19. void clear(int value) {  
20.     bitmap[value >> SHIFT] &= ~(1 << (value & MASK));  
21. }  
22.   
23. //测试bitmap第value位是否为1  
24. int test(int value) {  
25.     return bitmap[value >> SHIFT] & (1 << (value & MASK));  
26. }  
27.   
28. int main() {  
29.     int a[] = {12, 5, 1, 89, 64, 49, 77, 91, 3, 0, 32, 50, 99};  
30.     int length = sizeof(a) / sizeof(int);  
31.   
32.     //将bitmap所有位设置为0  
33.     for (int i = 0; i < N; ++i) {  
34.         clear(i);  
35.     }  
36.   
37.     //bitmap中将待排序数组中值所在的位设置为1  
38.     for (int i = 0; i < length; i++)  
39.         set(a[i]);  
40.   
41.     //输出排序后的结果  
42.     for (int i = 0; i < N; ++i) {  
43.         if (test(i))  
44.             cout << i << " ";  
45.     }  
46. }  

如上代码中：

      N表示待排序整数的上限，例如本题要求的10^7。那么申请一个N位大小的bitmap：int bitmap[1 + N / WIDTHWORD]; 

      设置、清除、测试函数的含义可以参考文章： http://blog.163.com/xb_stone_yinyang/blog/static/2118160372013625112558579/，

下面给出这几个函数的简要解释：

 

对于一个整数value，要将其对应到bitmap中的第value位，如果设置第value位为1呢？

看设置函数：value >> SHIFT 是找到value在bitmap中对应的是第几个int型数的位置，例如整数100，它对应的是int数组（也就是bitmap）的第 100 >> 5 == 100 / 32 == 3个int型的位置（从0开始计数，每个int型占据32位）；然后再在int数组（也就是bitmap）的第3个位置中寻找需要将第几位设置为1： 1 << (value & 0x1f) == 1 << 100 & 31 == 1 << 4，即要将1左移四位就是要设置为1的那一位；bitmap[value >> SHIFT] |= (1 << (value & MASK));  最终完成将bitmap的第100位设置为1。

 

对于一个整数value，如何将其对应到bitmap中的那位的上的1清除掉呢？

看清除函数，和设置函数一样，value >> SHIFT 是找到value在bitmap中对应的是第几个整型的位置；然后，1 << (value & 0x1f)在找到的那个整型的位置中判断要将该字节的哪一位设置为0；bitmap[value >> SHIFT] &= ~(1 << (value & MASK));完成最终清除工作。

 

对于一个整数value，如何测试在bitmap中是否包含该数，也就是bitmap中第value位上是否为1？

也是先找到value对应bitmap中第几个整型位置，然后在该位置中找到对应的位，再看该位上是否为1，为1表示bitmap中包含value。

 

程序排序结果：

 

2、使用C++的bitset

[cpp]  view plain  copy

 

1. #include <iostream>  
2. #include <bitset>  
3. #define N 100  
4. using namespace std;  
5.   
6.   
7. int main() {  
8.        int a[] = {12, 5, 1, 89, 64, 49, 77, 91, 3, 0, 32, 50, 99};  
9.        int length = sizeof(a) / sizeof(int);  
10.   
11.   
12.        //直接使用C++bitset，申请Nbit的空间，每一位均设置为0  
13.        bitset<N> bitmap;   
14.   
15.   
16.        //遍历待排序数组，将bitmap中对应位设置为1  
17.        for (int i = 0; i < length; i++)  
18.             bitmap.set(a[i], 1);  
19.   
20.   
21.        //输入排序结果  
22.        for (int i = 0; i < N; ++i) {  
23.             if (bitmap[i])  
24.                cout << i << " ";  
25.        }  
26. }  

二、需要多次bitmap排序

        如果上限N更大或者进一步限制内存大小（例如，将内存限制在0.5M之内），那么一次bitmap就不能将所有数据排序。需要多次bitmap排序，例如上面排序小于100的一些数，我们上面的一次bitmap，是申请100位的bitmap；但是，如果限制我们只能使用30位bitmap，那么久需要排序100 / 30 + 1次：第一次排序0 ~ 29之间的数，第二次排序30 ~ 59之间的数，第三次排序60 ~ 89之间的数，第四次排序90 ~ 100之间的数。

      如果是k次bitmap排序，那么时间复杂度为O(kn)，空间开销为O(n / k 位).

下面只给出C++方式，C方式类似：

 

[cpp]  view plain  copy

 

1. int main() {  
2.       int a[] = {12, 5, 1, 89, 64, 49, 77, 91, 3, 0, 32, 50, 99};  
3.       int length = sizeof(a) / sizeof(int);  
4.   
5.       //假设还是有小于100的不重复整数需要排序，但是  
6.       //不能申请100位空间，只能申请30位空间，那么，需要  
7.       //排序的次数如下：  
8.       int sort_times = N / 30 + 1;  
9.   
10.   
11.       //那么，第一趟先排序0-29，第二趟排序30-59，  
12.       //第三趟排序60-89，第四趟排序剩下的  
13.       bitset<30> bitmap;             //只能申请30位的bitmap  
14.       for (int times = 0; times < sort_times; ++times) {   //一共进行四趟排序  
15.            bitmap.reset();                             //记得每次排序前将bitmap清空为0  
16.            for (int i = 0; i < length; i++) {  
17.                   if (a[i] >= 30 * times && a[i] < 30 * (times + 1))    
18.                          bitmap.set(a[i] - 30 * times);  
19.            }  
20.   
21.   
22.            for (int i = 0; i < 30; ++i) {  
23.                 if (bitmap[i])  
24.                       cout << i + 30 * times << " ";  
25.            }  
26.       }  
27. }  

 

三、如果每个整数最多出现m次，如何排序?

       上述两部分讨论的是如果整数是不重复时的排序，那么，如果海量整数， 每个整数允许重复，但是重复次数不超过m（例如m == 10），如何排序？

        方法：如果每个整数重复出现次数不超过10次，那么，可以用 4位表示一个整数，用这四位统计该数出现次数，然后排序后输出该数时，输出m次即可。

四、除了排序，bitmap的其他用途

如上，bitmap可以用于不重复正整数排序，那么，bitmap其他用途：

1、找出不重复数：

第13题： 在2.5亿个整数中找出不重复的整数，内存不足以容纳这2.5亿个整数。

2、判断某数是否存在于海量整数中：

第15题： 给40亿个不重复的unsigned int的整数，没排过序的，然后再给一个数，如何快速判断这个数是否在那40亿个数当中？

 

Java中也有对应的实现，java.util.BitSet,

完全是为这个量身定做的java类。

这个类从jdk1.0开始就有了，不过其中的某些方法是jdk1.4以后才有的，

大家用的时候要当心。

另外BitSet是非线程安全的，需要外部同步。

 

转载于:https://www.cnblogs.com/davidwang456/p/6180935.html