c语言求交集算法

1. 如何用C语言编写求交集和并集的程序

char c[20];//存储交集的字符int count=0;//统计交集个数for (n=1;n<j;n++)
for (m=1;m<=k;m++)
{
if(a[n]==b[m]) { c[count]=a[n]; count++; }
}
} c[count]='\0';printf("交集为%s",c);

2. 求C语言描述的,用线性表的,求交集的算法

先排序两个先行表，然后去除重复项。
从一个表(a)第一项开始，为关键字扫描另一个表(b)，找一个与其相等的，如果找到，那么在b表之前的项也不会是a表中的项了，然后从a表下一项作关键字，从b表被匹配的元素的下一项开始继续搜索，如果没有找到与a中第一项相等的，到遇到比该项大的项时，便从a中下一项开始，重复以上步骤。

排序就不说了，好多种，冒泡，快排，插入，二分插入都行。去除重复项，可以用以下算法
void StripRepeatElement(int Array[],int Arraylen)
{
int Count = 0;//重复计数器
int i;

for(i = 0;i < ArrayLen;i++)
{
if(Array[i] == Array[i + 1])
{
Count++;
}
else
{
Array[i - Count] = Array[i];
}
}
}
复杂度为O(n)
以下为求交集的算法，假设两个表都已经排过序和剔出重复项了
void GetIntersection(int A[],int Alen,int B[],int Blen)
{
int i = 0,j = 0;

while(i < Alen)
{
while(j < Blen)
{
if(A[i] == B[j])
{
//交集
printf(" %d ",A[i]);
j++;
break;
}
else if(A[i] < B[j])
{
//从A的下一项开始匹配
break;
}
else
{
//比较B的下一项
j++;
}
}
i++;
}
}
复杂度也为O(n)

3. C语言编程，输入两个数列，求交集！

#include<stdio.h>
#include<stdlib.h>

int main()
{
int i,j,k,len=0,a[10],b[10],c[10];

for(i=0;i<10;i++)
{
scanf("%d",&a[i]);
}
for(i=0;i<10;i++)
{
scanf("%d",&b[i]);
}
for(i=0;i<10;i++)
{
for(k=0;k<len;k++)
{
if(a[i]==c[k])
{
break;
}
}
if(k>=len)
{
for(j=0;j<10;j++)
{
if(a[i]==b[j])
{
c[len++]=a[i];
break;
}
}
}

}
for(i=0;i<len;i++)
{
printf("%d ",c[i]);
}
printf("\n");
return 0;
}

4. 如何写一个c语言程序求两个集合的交集

定义两个数组存放这两个集合，再定义一个数组存放它们的集合，用类似冒泡排序的算法，遍历数组1中的第一个元素和数组2中每一个元素，若有相同的，则把这个元素放入第三个数组，继续遍历，知道数组1遍历完所有元素，那数组3中的元素，即为两个数组(集合)的交集。

5. c语言求交集编程

程序如下（TC2.0下运行通过）：
#include <stdio.h>
#include <alloc.h>

#define SET_TYPE unsigned char /*集合所用数据类型*/
#define SET_END 0xff /*集合结束符*/
#define SET_NUM 3 /*集合个数*/

SET_TYPE A[] = {1,2,3,4,5,9,8,6,0,SET_END};
SET_TYPE B[] = {3,4,5,6,7,10,11,22,SET_END};
SET_TYPE C[] = {2,3,5,6,7,9,20,SET_END};

SET_TYPE *pSets[SET_NUM] = {A,B,C};

long setSize(const SET_TYPE *pset);
void insertSort(SET_TYPE *BigSet,const SET_TYPE *SmallSet);
main()
{
SET_TYPE *AuBuC;
long element_num=0;
long i;
long j;
int sameFlag=0;
int sameNum=0;
clrscr();
for(i=0;i<SET_NUM;i++){/*得到所有集合元素数总和*/
element_num+=setSize(pSets[i]);
}
AuBuC = (SET_TYPE *)malloc(sizeof(SET_TYPE)*(element_num+1));
for(i=0;i<element_num+1;i++){
AuBuC[i] = SET_END;
}
for(i=0;i<SET_NUM;i++){/*插入法排序*/
insertSort(AuBuC,pSets[i]);
}
for(i=0;i<element_num;i++){
printf("%d ",AuBuC[i]);
}
printf("\n");
for(i=0;i<element_num;i++){
if(AuBuC[i]==AuBuC[i+1]){
if(sameFlag==1){
sameNum++;
}else{
sameNum=1;
sameFlag=1;
}
}else{
sameNum=0;
sameFlag=0;
}
if(sameNum==SET_NUM-1){
for(j=0;j<SET_NUM;j++){
AuBuC[i-sameNum+1+j]=SET_END;
}
}
}
for(i=0;i<element_num;i++){
if(AuBuC[i]!=AuBuC[i+1]&&AuBuC[i]!=SET_END){
printf("%d ",AuBuC[i]);
}
}
free(AuBuC);
}

long setSize(const SET_TYPE *pset)/*得到集合元素个数*/
{
long i=0;
while(pset[i++]!=SET_END){
i=i;
}
return i-1;
}

void insertSort(SET_TYPE *BigSet,const SET_TYPE *SmallSet)
{
long i=0;
long j;
long k;
while(SmallSet[i]!=SET_END){
j = 0;
while(BigSet[j]!=SET_END && BigSet[j]<SmallSet[i]){/*从小到大排序*/
j++;
}
if(BigSet[j]==SET_END){
BigSet[j] = SmallSet[i];
}else{/*BigSet[j]>=SmallSet[i]*/
k = j;
while(BigSet[j++]!=SET_END);
while(j>k){
BigSet[j] = BigSet[j-1];
j--;
}
BigSet[k] = SmallSet[i];
}
i++;
}
}

自己弄的。。。

6. 如何用C语言编写求交集和并集的程序求解

scanf ("%s",a);
j=strlen(a);
printf ("请输入第二个集合内容\n");
scanf ("%s",b);
k=strlen(b);
printf ("集合的交集是："); ///////////////////////计算2个数组的交集//////////////////// //flag标志位,index数组下标标志位 int flag=1, index=0; //c[20]保存交集的数组，d[40]保存并集的数组
char c[20]="",d[40]="";
for (n=0;n<j;n++){for (m=0;m<=k;m++){if(a[n] == b[m]){c[index++] = a[n];break;}}}printf("\n%s\n",c); ////////////////////////////计算2个数组的并集/////////////////////// flag=1;index=0;for (n=0;n<j;n++){for(m=0;m<index;m++){if(d[m] == a[n])flag=0;}if(flag){d[index++]=a[n];}flag=1;}flag=1;for (n=0;n<j;n++){for(m=0;m<index;m++){if(d[m] == b[n])flag=0;}if(flag){d[index++]=b[n];}flag=1;} printf ("集合的并集是：");

7. C语言怎么用函数求集合的交集

首先，如果是数学上的集合概念，那就说明，集合A自身的每个元素都不相同。
那么，程序就可以简化成，
设数组key[52]，用于记录字母出现次数。
扫描一次集合A，把出现的字母计到key的对应位置里。
同理扫描一次集合B。
查看key数组，>=2的对应字母输出到集合C，C就是所求交集。

8. c语言求两个数组的并交集

只简单地分析了一下交集的情况，求并集类似。网络知道这个代码支持不怎么好，复制粘贴到 vs 之类的代码编辑器里面缩进一下会比较好看。

见代码如下：

#include <stdio.h>

#include <stddef.h>

#include <stdlib.h>

#include <time.h>

// 使用整型数组为例，其它数组同理

// 交集

// 通过迭代遍历判断相同元素，时间复杂度较高，平方量级

// 传入原数组及其长度、结果数组

// 返回结果数组的长度

// （需要自行保证结果数组足够大）

size_t getIntersection(array1, array1_len, array2, array2_len, result_array)

int* array1, * array2, * result_array;

size_t array1_len, array2_len;

{

size_t result_p = 0;

for (size_t i = 0; i < array1_len; ++i)

{

for (size_t j = 0; j < array2_len; ++j)

{

if (array1[i] == array2[j])

{

result_array[result_p++] = array1[i];

break;

}

}

}

return result_p;

}

// 另一种思路是用快速排序等高效的排序算法先将数组排序，

// 然后再遍历一次数组，这时因为已经排好序了，所以最多只要

// 遍历 array1_len + array2_len 即可，此时时间复杂度较低，

// 因为快速排序等一般是 nlog(n)，然后后面接一个一次量级的遍历，

// 总的来说是 nlog(n) + n，也就是 nlog(n)，比 n^2 要快一些。

int intAscendingComparor(const void* left, const void* right)

{

return *(int*)left - *(int*)right;

}

// 交集

// 先排序后遍历判断相同元素，时间复杂度较低

// 传入原数组及其长度、结果数组

// 返回结果数组的长度

// （需要自行保证结果数组足够大）

size_t getIntersection_optimized(array1, array1_len, array2, array2_len, result_array)

int* array1, * array2, * result_array;

size_t array1_len, array2_len;

{

size_t result_p = 0;

size_t i = 0;

// 使用标准库的 qsort 比较方便

int* tmpArray = (int*)malloc(sizeof(int) * (array1_len + array2_len));

for (i = 0; i < array1_len; ++i) tmpArray[i] = array1[i];

for (i = 0; i < array2_len; ++i) tmpArray[array1_len + i] = array2[i];

qsort(tmpArray, array1_len + array2_len, sizeof(int), intAscendingComparor);

for (size_t i = 0; i < array1_len + array2_len - 1; ++i)

{

if (tmpArray[i] == tmpArray[i + 1])

{

result_array[result_p++] = tmpArray[i];

do {

++i;

} while (i < array1_len + array2_len - 1 && tmpArray[i] == tmpArray[i + 1]);

}

}

free(tmpArray); tmpArray = NULL;

return result_p;

}

// 自定义的一个简单的输出数组内容的函数

void printArray(int* array, size_t len)

{

for (size_t i = 0; i < len - 1; ++i)

{

printf("%d, ", array[i]);

}

printf("%d", array[len - 1]);

}

int main()

{

clock_t start, end;

int first_array[5] = { 1, 2, 3, 4, 5 };

int second_array[4] = { 4, 5, 6, 7 };

printf("数组1为：{ 1, 2, 3, 4, 5 }，数组2为：{ 4, 5, 6, 7 } ");

// 第一种方法

int result_array[10];

start = clock();

size_t result_array_len = getIntersection(first_array, 5, second_array, 4, result_array);

end = clock();

printf("交集为：{ ");

printArray(result_array, result_array_len);

printf(" }，使用时间：%d ms ", (end - start) * 1000 / CLOCKS_PER_SEC);

// 第二种方法

start = clock();

result_array_len = getIntersection_optimized(first_array, 5, second_array, 4, result_array);

end = clock();

printf("使用优化算法求出的交集：{ ");

printArray(result_array, result_array_len);

printf(" }，使用时间：%d ms ", (end - start) * 1000 / CLOCKS_PER_SEC);

// 接下来用两个比较大的数组，测试一下两种方法的效率

printf(" 下面是测试，求一个包含 100000 个元素和一个包含 199999 个元素的数组的交集： ");

#define len1 100000

#define len2 199999

int* testArray1 = (int*)malloc(sizeof(int) * len1);

int* testArray2 = (int*)malloc(sizeof(int) * len2);

int* testArray = (int*)malloc(sizeof(int) * len1);

start = clock();

for (size_t i = 0; i < len1; ++i) testArray1[i] = i;

for (size_t i = 0; i < len2; ++i) testArray2[i] = i + 12345;

end = clock();

printf("初始化数组用时：%d ms ", (end - start) * 1000 / CLOCKS_PER_SEC);

start = clock();

result_array_len = getIntersection(testArray1, len1, testArray2, len2, testArray);

end = clock();

printf("第一种方法用时：%d ms ", (end - start) * 1000 / CLOCKS_PER_SEC);

start = clock();

result_array_len = getIntersection_optimized(testArray1, len1, testArray2, len2, testArray);

end = clock();

printf("第二种方法用时：%d ms ", (end - start) * 1000 / CLOCKS_PER_SEC);

return 0;

}

注释应该说明得比较清楚了，这里就不赘言了。

下面分别是在 Windows 上 msvc 和 mingw 编译并运行的结果：

mingw

9. 用c语言求两个集合的交集，并集，差集

#include<stdio.h>
#include<string.h>
#include<conio.h>

#defineARR_LEN255		/*数组长度上限*/
#defineelemTypechar	/*集合元素数据类型*/

/*集合数据结构*/
typedefstructset{
	elemTypedata[ARR_LEN];
	intlength;
}set;

/*初始化集合*/
voidinitSet(set*S){
	S->length=0;
}

/*交集*/
/*A与B的交集（A∩B）：既属于A又属于B的元素构成的集合*/
intsetIntersection(setA,setB,set*dest){
	inti=0,j=0,k=0;
	dest->length=0;
	for(i=0;i<A.length;i++){/*外循环遍历A*/
		for(j=0;j<B.length;j++){/*内循环遍历B*/
			if(A.data[i]==B.data[j]){/*既属于A又属于B的元素，存入dest*/
				dest->data[k]=A.data[i];
				k++;
			}
		}
	}
	dest->length=k;
	if(dest->length)
		return1;
	else
		return0;
}

/*并集*/
/*A与B的并集（A∪B）：A与B所有元素构成的集合*/
intsetUnion(setA,setB,set*dest){
	inti=0,j=0,k=0;
	dest->length=0;
	for(i=0;i<A.length;i++){/*外循环遍历A*/
		for(j=0;j<B.length;j++){/*内循环遍历B*/
			if(A.data[i]==B.data[j])/*既属于A又属于B的元素，跳过*/
				break;
		}
		if(j==B.length){/*属于A但不属于B的元素，存入dest*/
			dest->data[k]=A.data[i];
			k++;
		}
	}
	for(j=0;j<B.length;j++){/*B的所有元素，存入dest*/
		dest->data[k]=B.data[j];
		k++;
	}
	dest->length=k;
	if(dest->length)
		return1;
	else
		return0;
}

/*补集*/
/*B在A中的相对补集（A＼B）：属于A但不属于B的元素构成的集合*/
intsetComplement(setA,setB,set*dest){
	inti=0,j=0,k=0;
	dest->length=0;
	for(i=0;i<A.length;i++){/*外循环遍历A*/
		for(j=0;j<B.length;j++){/*内循环遍历B*/
			if(A.data[i]==B.data[j])/*既属于A又属于B的元素，跳过*/
				break;
		}
		if(j==B.length){/*属于A但不属于B的元素，存入dest*/
			dest->data[k]=A.data[i];
			k++;
		}
	}
	dest->length=k;
	if(dest->length)
		return1;
	else
		return0;	
}

/*打印集合内容*/
intprintSet(setS){
	inti;
	if(S.length==0){
		puts("Thesetisempty!");
		return0;
	}
	for(i=0;i<S.length;i++)
		printf("%c",S.data[i]);
	putchar('
');
	return1;
}

intmain(void){
	setA,B;
	setAIB,AUB,ACB;/*交集、并集、补集*/
	
	initSet(&A);initSet(&B);
	initSet(&AIB);initSet(&AUB);initSet(&ACB);
	
	strcpy(A.data,"123");
	A.length=strlen(A.data);
	strcpy(B.data,"4532");
	B.length=strlen(B.data);
	
	printf("A:	");
	printSet(A);
	printf("B:	");
	printSet(B);
	putchar('
');
	
	printf("A∩B:	");
	setIntersection(A,B,&AIB);
	printSet(AIB);
	
	printf("A∪B:	");
	setUnion(A,B,&AUB);
	printSet(AUB);

	printf("A＼B:	");
	setComplement(A,B,&ACB);
	printSet(ACB);
	
	getch();/*屏幕暂留*/
	return0;
}

10. 如何用C语言编写求交集和并集的程序

printf ("请输入第一个集合内容\n"); scanf ("%s",a); j=strlen(a); printf ("请输入第二个集合内容\n"); scanf ("%s",b); k=strlen(b); printf ("集合的交集是："); ///////////////////////计算2个数组的交集//////////////////// //flag标志位,index数组下标标志位 int flag=1, index=0; //c[20]保存交集的数组，d[40]保存并集的数组 char c[20]="",d[40]=""; for (n=0;n<j;n++){for (m=0;m<=k;m++){if(a[n] == b[m]){c[index++] = a[n];break;}}}printf("\n%s\n",c); ////////////////////////////计算2个数组的并集/////////////////////// flag=1;index=0;for (n=0;n<j;n++){for(m=0;m<index;m++){if(d[m] == a[n])flag=0;}if(flag){d[index++]=a[n];}flag=1;}flag=1;for (n=0;n<j;n++){for(m=0;m<index;m++){if(d[m] == b[n])flag=0;}if(flag){d[index++]=b[n];}flag=1;} printf ("集合的并集是：");