⑴ C++中如何计算两个区域是否有交集
两个区域应该都有x坐标和y坐标吧？判断第二个区域的左上点和左下点是否在第一个区域里即可，如果在的话，就说明有焦急，如果不在的话，就没有交集。
⑵ 如何写一个c语言程序求两个集合的交集
定义两个数组存放这两个集合，再定义一个数组存放它们的集合，用类似冒泡排序的算法，遍历数组1中的第一个元素和数组2中每一个元素，若有相同的，则把这个元素放入第三个数组，继续遍历，知道数组1遍历完所有元素，那数组3中的元素，即为两个数组(集合)的交集。
⑶ 求教如何用C语言求两个字母集合的交集
首先，如果是数学上的集合概念，那就说明，集合A自身的每个元素都不相同。
那么，程序就可以简化成，
设数组key[52]，用于记录字母出现次数。
扫描一次集合A，把出现的字母计到key的对应位置里。
同理扫描一次集合B。
查看key数组，>=2的对应字母输出到集合C，C就是所求交集。
⑷ 求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)
⑸ c语言算法求两个集合交集代码解释，最后两句t->next=hc; hc=t;各是什么意思
在你给出的代码中，找不到hc的定义，也就是说代码不全。
所以不进行全局代码解释
从题目中得到的信息是，找两个集合的交集，用C语言的描述就是找数据的相同点的位置。具体你看着办 嘿嘿^_^
⑹ c语言中有没有比较简单的算法来判断两个集合有交集
只判断有没有交集的话很简单了，直接挨个比较就可以了，如果有相同的返回1，没相同的返回0。
如果要求2个数组相交的元素的话自己写一个代码也可以，或者可以直接使用STL算法中的set_intersection函数。
⑺ c#判断两个集合是否有交集
使用HashTable，内置的方法提供了输出交集。
但是HashTable不允许重复项，这点需要注意
⑻ 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
⑼ 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;
}