求解集合的交集问题

思路1：排序法

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

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

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

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

#include <stdio.h>
#include <stdlib.h>
#define M 8
#define N 5
int cmp(const void *a, const void *b)
{
    int *x = (int *)a;
    int *y = (int *)b;
    return (*x) - (*y);
}

int main(void)
{
    int A[] = {-1, 2 ,39 ,10, 6, 11, 188, 10};
    int B[] = {39 ,8 , 10, 6, -1};
    //对数组A和数组B进行快排
    qsort(A, M, sizeof(int), cmp);
    qsort(B, N, sizeof(int), cmp);
    //FindIntersection(A, B);
    int i = 0, j = 0;
    int cnt = 0;
    int result[M > N ? M : N];//保存集合的结果
    //设置i、j索引，分别指向数组A和B，相等则同时移动，不相等则移动较小值的索引
    while(i < M && j < N)
    {
        if(A[i] == B[j])
        {
            result[cnt] = A[i];
            i++;
            j++;
            cnt++;
        }
        else if(A[i] < B[j])
        {
            i++;
        }
        else
        {
            j++;
        }
    }
    for(i = 0; i < cnt; i++)
    {
        printf("%4d", result[i]);
    }
    return 0;
}

思路2：索引法　

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

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

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

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

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

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

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

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define M 6
#define N 5
int Mymin(int a, int b)
{
    return a < b ? a : b;//此处是有小技巧的，当a==b==1时返回1，其他返回0
}
void Test(void)
{
    int A[] = {1, 10, 12, 23, 5, 45};
    int B[] = {1, 10, 12, 123, 52};

    //find MaxNumber in A
    int ifindA = 0;
    int MaxInA = A[0];
    for(ifindA = 0; ifindA < M; ifindA++)
    {
        MaxInA = MaxInA > A[ifindA] ? MaxInA : A[ifindA];
    }
    //find MaxNumber in B
    int ifindB = 0;
    int MaxInB = 0;
    for(ifindB = 0; ifindB < M; ifindB++)
    {
        MaxInB = MaxInB > A[ifindB] ? MaxInB : A[ifindB];
    }

    int *AsubPositive = (int *)malloc(sizeof(int) * (MaxInA + 1));
    int *BsubPositive = (int *)malloc(sizeof(int) * (MaxInB + 1));
    memset(AsubPositive, 0, sizeof(int) * (MaxInA + 1));
    memset(BsubPositive, 0, sizeof(int) * (MaxInB + 1));


    //COPY Positive and Negative numbers of A
    int i = 0;
    for(i = 0; i < M; i++)
    {
        AsubPositive[A[i]]++;
    }
    //COPY Positive and Negative numbers of B
    int j = 0;
    for(j = 0; j < N; j++)
    {
        BsubPositive[B[j]]++;
    }

    int  k = 0;
    int icount = 0;
    //扫描AsubNegative和BsubPositive
    printf("the Intersection of A and B is : { ");
    for(k = 0; k < M; k++)
    {
        //有交集输出该数
        icount = Mymin(AsubPositive[A[k]], BsubPositive[A[k]]);
        if(icount == 1)
        {
            printf("%-3d",A[k]);
        }
        A[k] = 0;
    }
    printf(" }");

}

/**
给40亿个不重复的unsigned int的整数，没排过序的，然后再给一个数，
如何快速判断这个数是否在那40亿个数当中
申请512M的内存
一个bit位代表一个unsigned int值
读入40亿个数，设置相应的bit位
读入要查询的数，查看相应bit位是否为1，为1表示存在，为0表示不存在
*/

void BitmapChar(){
	unsigned int bitmap[100]={0};//10000*32，能保存32万个数字
	FILE *fp;
	fopen_s(&fp,"data.txt","r");
	unsigned int value;
	while(!feof(fp)){ //把数据存到位图中
			fscanf_s(fp,"%8u",&value);
			//std::cout<<value<<'\t';
			int bytesPosition=value/32; //一个int占32位,求字节序
			int bitPosition=value&31;//位运算，求位序
			unsigned int tempposition=1<<bitPosition;
			bitmap[bytesPosition]=bitmap[bytesPosition]|tempposition;//把相对应的位置一
			
	}	
	fclose(fp);
	//从位图中读数据
	int vlaue=0;
	int count=0;
	for(int i=0;i<100;i++)
		for(int j=0;j<32;j++)
			
			if(bitmap[i]&(1<<j)){
				value=i*32+j;
				std::cout<<value<<'\t';
				count++;
				if(count%8==0)
					std::cout<<std::endl;	
			}
	
}

扩展：给定两个整数集合 A和 B，每个集合都包含 20亿个不同整数，请给出快速计算 A∩ B的算法，算法可使用外存，但是要求占用内存不能超过 4GB。分析：假如位图的位一共有n位,则存储的最大正整数是n-1,要注意数的范围，否则存入位图的时候会出错。

如有负数，则需要另外设一个存储负数的位图，分别处理

void Bitmapintersect(){
	unsigned int bitmapA[100]={0};//100*32
	unsigned int bitmapB[100]={0};
	FILE *fpA,*fpB;
	fopen_s(&fpA,"dataA.txt","r");
	fopen_s(&fpB,"dataB.txt","r");
	unsigned int value;
	//有重复的情况无影响
	while(!feof(fpA)){ //把A数据存到位图中A
			fscanf_s(fpA,"%8u",&value);
			//std::cout<<value<<'\t';
			int bytesPosition=value/32; //一个int占32位,求字节序
			int bitPosition=value&31;//位运算，求位序
			unsigned int tempposition=1<<bitPosition;
			bitmapA[bytesPosition]=bitmapA[bytesPosition]|tempposition;//把相对应的位置一
			
	}	
	fclose(fpA);
	while(!feof(fpB)){ //把B数据存到位图中B
			fscanf_s(fpB,"%8u",&value);
			//std::cout<<value<<'\t';
			int bytesPosition=value/32; //一个int占32位,求字节序
			int bitPosition=value&31;//位运算，求位序
			unsigned int tempposition=1<<bitPosition;
			bitmapB[bytesPosition]=bitmapB[bytesPosition]|tempposition;//把相对应的位置一
			
	}	
	fclose(fpB);
	
	//求交集
	FILE *fpAB;
	fopen_s(&fpAB,"dataAB.txt","w");

	for(int i=0;i<100;i++)
		for(int j=0;j<32;j++)
			if(bitmapA[i]&(1<<j)&&bitmapB[i]&(1<<j)){
				value=i*32+j;
				fprintf(fpAB,"%8u",value);
			}
	fclose(fpAB);
}

添加一段新建集合数据的代码：

void CreateRandomNumChar(){
	FILE *fp;
	fopen_s(&fp,"dataB.txt","w");
	srand((unsigned int)time(0)); //设置随机数种子
	unsigned int value;
	for(int i=0;i<3;i++)
	{
		for(int j=0;j<1000;j++)
			
			{
				
				value=rand()%3199;
				fprintf(fp,"%-8d",value);
			}
		
	}

	fclose(fp);

}