一步一步写算法（之寻找丢失的数）

原贴地址:http://blog.csdn.net/feixiaoxing/article/details/6945730

【 声明：版权所有，欢迎转载，请勿用于商业用途。  联系信箱：feixiaoxing @163.com】

    假设我们有一个1亿个数据，其中数据的范围是0~1亿，也就是100M的数据。但是这个数组中丢了一些数据，比如说少了5啊，少了10啊，那么有什么办法可以把这些丢失的数据找回来呢？这个题目不难，但是它可以帮助我们拓展思路，不断提高算法的运行效率。

    对于这个问题，我们一个最简单的思路就是对各个数据进行flag判断，然后依次输出数据。

[cpp]  view plain copy

1. void get_lost_number(int data[], int length)  
2. {  
3.     int index;  
4.   
5.     assert(NULL != data && 0 != length);  
6.     unsigned char* pFlag = (unsigned char*)malloc(length * sizeof(unsigned char));  
7.     memset(pFlag, 0, length * sizeof(unsigned char));  
8.   
9.     for(index = 0; index < length; index ++){  
10.         if(0 == pFlag[data[index]])  
11.             pFlag[data[index]] = 1;  
12.     }  
13.   
14.     for(index = 0; index < length; index++){  
15.         if(0 == pFlag[index])  
16.             printf("%d\n", index);  
17.     }  
18.   
19.     free(pFlag);  
20.     return;  
21. }  

    可能朋友也看到了，上面的代码需要分配和原来数据一样length的空间。其实我们可以用bit进行访问标志的设定，所以我们申请的空间还可以减少。

[cpp]  view plain copy

1. void get_lost_number(int data[], int length)  
2. {  
3.     int index;  
4.       
5.     assert(NULL != data && 0 != length);  
6.     unsigned char* pFlag = (unsigned char*)malloc((length + 7) >> 3);  
7.     memset(pFlag, 0, length * sizeof(unsigned char));  
8.       
9.     for(index = 0; index < length; index ++){  
10.         if(0 == (pFlag[data[index] >> 3] & (1 << (data[index] % 8))))  
11.             pFlag[data[index] >> 3] |= 1 << (data[index] % 8);  
12.     }  
13.       
14.     for(index = 0; index < length; index++){  
15.         if(0 == (pFlag[data[index] >> 3] & (1 << (data[index] % 8))))  
16.             printf("%d\n", index);  
17.     }  
18.       
19.     free(pFlag);  
20.     return;  
21. }  

    上面的代码已经在空间上面有所减小，那么有什么办法并行运算这些数据呢？

[cpp]  view plain copy

1. void get_lost_number(int data[], int length)  
2. {  
3.     int index;  
4.     RANGE range[4] = {0};  
5.       
6.     assert(NULL != data && 0 != length);  
7.     unsigned char* pFlag = (unsigned char*)malloc((length + 7) >> 3);  
8.     memset(pFlag, 0, length * sizeof(unsigned char));  
9.   
10.     range[0].start = 0,               range[0].end = length >> 2;  
11.     range[1].start = length >> 2 ,    range[1].end = length >> 1;  
12.     range[2].start = length >> 1 ,    range[2].end = length >> 2 * 3;  
13.     range[3].start = length >> 2 * 3, range[3].end = length;  
14.   
15. #pragma omp parallel for  
16.     for(index = 0; index < 4; index ++){  
17.         _get_lost_number(data, range[index].start, range[index].end, pFlag);  
18.     }  
19.       
20.     for(index = 0; index < length; index++){  
21.         if(0 == (pFlag[data[index] >> 3] & (1 << (data[index] % 8))))  
22.             printf("%d\n", index);  
23.     }  
24.       
25.     free(pFlag);  
26.     return;  
27. }  

    为了多核的并行计算，我们添加了子函数_get_lost，我们进一步补充完整。

[cpp]  view plain copy

1. typedef struct _RANGE  
2. {  
3.     int start;  
4.     int end;  
5. }RANGE;  
6.   
7. void _get_lost_number(int data[], int start, int end, unsigned char pFlag[])  
8. {  
9.     int index;  
10.   
11.     for(index = start; index < end; index++){  
12.         if(0 == (pFlag[data[index] >> 3] & (1 << (data[index] % 8))))  
13.             pFlag[data[index] >> 3] |= 1 << (data[index] % 8);  
14.     }  
15. }  

工作总结：

    （1）代码的优化是可以不断进行得，但是不见得适用于所有的场景

    （2）目前的cpu已经开始从2核->4核->8核转变，朋友们在可能的情况下尽量多掌握一些多核编程的知识。