集合A，B求其交集只适合正整数

思路1：排序法

　　对集合A和集合B进行排序（升序，用快排，平均复杂度O(N*logN)），设置两个指针p和q，同时指向集合A和集合B的最小值，不相等的话移动*p和*q中较小值的指针，相等的话同时移动指针p和q，并且记下相等的数字，为交集的元素之一，依次操作，直到其中一个集合没有元素可比较为止。

　　优点：操作简单，容易实现。

　　缺点：使用的排序算法不当，会耗费大量的时间，比如对排好序的集合使用快排， 时间复杂度是O(N²)

　　这种算法是大家都能比较快速想到的办法，绝大多数时间放在了对集合的排序上，快排的平均复杂度是O(N*logN)，对排好序的集合做查找操作，时间复杂度为O（N），当然这种算法肯定比遍历要快多了。

code：

[cpp]  view plain copy

1. #include <stdio.h>  
2. #include <stdlib.h>  
3. #define M 8  
4. #define N 5  
5. int cmp(const void *a, const void *b)  
6. {  
7.     int *x = (int *)a;  
8.     int *y = (int *)b;  
9.     return (*x) - (*y);  
10. }  
11.   
12. int main(void)  
13. {  
14.     int A[] = {-1, 2 ,39 ,10, 6, 11, 188, 10};  
15.     int B[] = {39 ,8 , 10, 6, -1};  
16.     //对数组A和数组B进行快排  
17.     qsort(A, M, sizeof(int), cmp);  
18.     qsort(B, N, sizeof(int), cmp);  
19.     //FindIntersection(A, B);  
20.     int i = 0, j = 0;  
21.     int cnt = 0;  
22.     int result[M > N ? M : N];//保存集合的结果  
23.     //设置i、j索引，分别指向数组A和B，相等则同时移动，不相等则移动较小值的索引  
24.     while(i < M && j < N)  
25.     {  
26.         if(A[i] == B[j])  
27.         {  
28.             result[cnt] = A[i];  
29.             i++;  
30.             j++;  
31.             cnt++;  
32.         }  
33.         else if(A[i] < B[j])  
34.         {  
35.             i++;  
36.         }  
37.         else  
38.         {  
39.             j++;  
40.         }  
41.     }  
42.     for(i = 0; i < cnt; i++)  
43.     {  
44.         printf("%4d", result[i]);  
45.     }  
46.     return 0;  
47. }  

思路2：索引法　

以空间换时间，把集合(感谢网友的指正，集合里面的元素是不重复的！)中的元素作为数组下表的索引。来看例子：      

A= {1 ,12, 13, 25}，那Asub[1] = 3,Asub[12] = 1 ,Asub[13] = 1 ,Asub[25] = 1 ;

B=｛1, 2,  3, 15 ,｝那Bsub[1] = 1; Bsub[2] = 1; Bsub[3] = 1; Bsub[15] = 1;

　　对元素少的集合扫一遍，发现Asub[1] = 3 和Bsub[1] = 1有相同的索引1，并且重复度为1，所以交集肯定包括{1, 1}; Bsub[2] = 1而Asub[2] = 0，表示无交集，依次类推，可以得到集合A和B的交集。

　　假设集合中存在负数，可以把集合分成正整数和负整数（加个负号变正整数）两部分，解法同上！

　　优点：速度快，时间复杂度O(N)

　　缺点：空间消耗大，以空间换取时间

　　这是我看到题目第一个想到的算法，再来想到排序法，而集合压缩是有感而发的，索引法的缺点是空间消耗多，原因是可能索引值太大，要申请很多的不必要的空间，这个缺点也是有克服的方法的，就是采用哈希查找，找到一个比较合适的哈希函数，把索引的值减小了，从而减少消耗的内存空间。比如哈希函数为f(x) = (x + MOD) % MOD （除留余数法，MOD为常数），还有平方取中法、折叠法等方法，然而，无论哈希函数设计有多么精细，都会产生冲突现象，也就是2个关键字处理函数的结果映射在了同一位置上，因此，有一些方法可以避免冲突。这里没有仔细钻研，只提供一些思路，有兴趣的朋友可以继续研究。

code：（我的代码仅适用与正整数部分，未处理负数）

 

[cpp]  view plain copy

1. /* 
2.     Tencent: A、B两个整数集合，设计一个算法求他们的交集，尽可能的高效 
3. */  
4. #include <stdio.h>  
5. #include <stdlib.h>  
6. #include <string.h>  
7. #define M 6  
8. #define N 5  
9. int Mymin(int a, int b)  
10. {  
11.     return a < b ? a : b;  
12. }  
13. int main(void)  
14. {  
15.     int A[] = {1, 10, 12, 23, 5, 45};  
16.     int B[] = {1, 10, 12, 123, 52};  
17.   
18.     //find MaxNumber in A  
19.     int ifindA = 0;  
20.     int MaxInA = A[0];  
21.     for(ifindA = 0; ifindA < M; ifindA++)  
22.     {  
23.         MaxInA = MaxInA > A[ifindA] ? MaxInA : A[ifindA];  
24.     }  
25.     //find MaxNumber in B  
26.     int ifindB = 0;  
27.     int MaxInB = 0;  
28.     for(ifindB = 0; ifindB < M; ifindB++)  
29.     {  
30.         MaxInB = MaxInB > A[ifindB] ? MaxInB : A[ifindB];  
31.     }  
32.   
33.     int *AsubPositive = (int *)malloc(sizeof(int) * (MaxInA + 1));  
34.     int *BsubPositive = (int *)malloc(sizeof(int) * (MaxInB + 1));  
35.     memset(AsubPositive, 0, sizeof(int) * (MaxInA + 1));  
36.     memset(BsubPositive, 0, sizeof(int) * (MaxInB + 1));  
37.   
38.   
39.     //COPY Positive and Negative numbers of A  
40.     int i = 0;  
41.     for(i = 0; i < M; i++)  
42.     {  
43.         AsubPositive[A[i]]++;  
44.     }  
45.     //COPY Positive and Negative numbers of B  
46.     int j = 0;  
47.     for(j = 0; j < N; j++)  
48.     {  
49.         BsubPositive[B[j]]++;  
50.     }  
51.   
52.     int  k = 0;  
53.     int icount = 0;  
54.     //扫描AsubNegative和BsubPositive  
55.     printf("the Intersection of A and B is : { ");  
56.     for(k = 0; k < M; k++)  
57.     {  
58.         //有交集输出该数  
59.         icount = Mymin(AsubPositive[A[k]], BsubPositive[A[k]]);  
60.         if(icount == 1)  
61.         {  
62.             printf("%-3d",A[k]);  
63.         }  
64.         A[k] = 0;  
65.     }  
66.     printf(" }");  
67.     return 0;  
68. }