并集插算法

⑴ 集合的交集与并集

【补充：A∩D={直角三角形}，B∩D={等腰直角三角形}】
交集就是既要属于A又要属于B，且的关系，类似于算法中的乘法，
而并集是属于A或者属于B，或的关系，类似于算法中的加法。

已知集合A={三角形}，B={等腰三角形}，C={等边三角形}，D={直角三角形}，那么A交B，B并C，C交D，A并D，B交C，B并D。
解：
A∩B={等腰三角形}，
B∪C={等腰三角形}，
C∩D=空集
A∪D={三角形}
B∩C={等边三角形}
B∪D={等腰三角形和直角三角形}

⑵ 请设计一个算法，,求A和B两个单链表表示的集合的交集、并集、差集

#include<stdio.h>
#include<stdlib.h>
typedef struct Node
{char data; /*定义了数据域，这里存储的是char类型*/
struct Node*next; /*定义了指针域*/
}*linklist;

void readdata(linklist head)
{ linklist p;
char a;
scanf("%c",&a);
while(a!='\n')
{ p=(linklist)malloc(sizeof(structNode));
p->data=a;
p->next=head->next;
head->next=p;
scanf("%c",&a);
}
}

void pop(linklist head)
{ linklist p;
p=head->next;
while(p!=NULL)
{ printf("%c",p->data);
p=p->next;
}
printf("\n");
}
/******求两个链表的并集******/
void bingji(linklist head1,linklisthead2,linklist head3)
{ linklist p1,p2,p3;
p1=head1->next;
while(p1!=NULL)
{ p2=head2->next;
while((p2!=NULL)&&(p2->data!=p1->data))
p2=p2->next;
if((p2!=NULL)&&(p2->data==p1->data))
{ p3=(linklist)malloc(sizeof(struct Node));
p3->data=p1->data;
p3->next=head3->next;
head3->next=p3; }
p1=p1->next; } }
/********求两个链表的交集********/
void jiaoji(linklist head1,linklisthead2,linklist head3)
{ linklist p1,p2,p3;
p1=head1->next;
while(p1!=NULL)
{ p3=(linklist)malloc(sizeof(struct Node));
p3->data=p1->data;
p3->next=head3->next;
head3->next=p3;
p1=p1->next; }
p2=head2->next;
while(p2!=NULL)
{ p1=head1->next;
while((p1!=NULL)&&(p1->data!=p2->data))
p1=p1->next;
if (p1==NULL)
{ p3=(linklist)malloc(sizeof(struct Node));
p3->data=p2->data;
p3->next=head3->next;
head3->next=p3; }
p2=p2->next;
}
}
/********求两个链表的差集************/
void chaji(linklist head1,linklisthead2,linklist head3)
{ linklist p1,p2,p3;
p1=head1->next;
while(p1!=NULL) //循环语句执行链表的差集运算
{ p2=head2->next;
while((p2!=NULL)&&(p2->data!=p1->data))
p2=p2->next;
if(p2==NULL)
{ p3=(linklist)malloc(sizeof(struct Node));
p3->data=p1->data;
p3->next=head3->next;
head3->next=p3;
}
p1=p1->next;
}
}

void main(linklist head1,linklisthead2,linklist head3)
{
int x;
printf("input values and end up with ‘enter’ \n");
head1=(linklist)malloc(sizeof(struct Node)); /*为结点分配内存空间*/
head1->next=NULL;
head2=(linklist)malloc(sizeof(struct Node));
head2->next=NULL;
head3=(linklist)malloc(sizeof(struct Node));
head3->next=NULL;
printf("please input ji he 1 \n");
readdata(head1);
printf("please input ji he 2 \n"); //调用链表输出函数链表数据
readdata(head2);
A:printf("1.bing ji 2.jiaoji 3.cha ji 4.exit \n");
do{
printf("qing xuan ze xu hao\n");
scanf("%d",&x);
switch(x)
{
case 1:
printf("liang ge ji he debing ji shi \n");
jiaoji(head1,head2,head3);
pop(head3);
head3->next=NULL;
break;
case 2:
printf("liang ge ji he dejiao ji shi \n");
bingji(head1,head2,head3);
pop(head3);
head3->next=NULL;
break;
case 3:
printf("liang ge ji he decha ji shi \n");
chaji(head1,head2,head3);
pop(head3);
head3->next=NULL;
break;
case 4: break;
default:goto A; }
}
while(x!=4);
}

⑶ 如何实现两个集合之间差集的算法

这是求并集的算法描述，链式结构实现的，参考一下
算法描述
LNode *Merge_LinkList(LNode *La， LNode *Lb)
/* 合并以La, Lb为头结点的两个有序单链表 */
{ LNode*Lc, *pa , *pb, *pc, *ptr ;
Lc=La; pc=La ; pa=La->next ; pb=Lb->next ;
while (pa!=NULL && pb!=NULL)
{ if (pa->data<pb->data)
{ pc->next=pa ; pc=pa ; pa=pa->next ; }
/* 将pa所指的结点合并，pa指向下一个结点 */
if (pa->data>pb->data)
{ pc->next=pb; pc=pb ; pb=pb->next ; }
/* 将pa所指的结点合并，pa指向下一个结点 */
if (pa->data==pb->data)
{ pc->next=pa ; pc=pa ; pa=pa->next ;
ptr=pb; pb=pb->next; free(ptr); }
/* 将pa所指的结点合并，pb所指结点删除 */
}
if (pa!=NULL) pc->next=pa ;
else pc->next=pb; /*将剩余的结点链上*/
free(Lb) ;
return(Lc) ;
}

⑷ 大家帮我看看求两个集合并集的算法

不是演着你的思路，不过是挺好的一个算法，上算法课时候的练习，你可以看一下
/*----------------------------------------------
先对两个集合A，B排序，这样集合的运算会很方便
求A-B，A交B，A并B
----------------------------------------------*/
#include<iostream>
#include <string>
#include <iomanip>
using namespace std;
#define n 4
#define m 6
#define max 12

void sort(int c[], int num)
{
for(int i =0; i < num; i++)
{
int temp = c[i];
for (int j = i-1; j >= 0; j--)
{
if(c[j] > temp) c[j+1] = c[j];
else break;
}
c[j+1] = temp;
}
}

void print_array(int a[],int num)
{
for(int i = 0; i < num ;i++)
cout << setw(4) << left << a[i];
cout << endl;
}
void main(void)
{
int a[] = {1,4,3,6};
int b[] = {1,4,7,8,5,2};
int len_a = sizeof(a)/sizeof(a[0]);
int len_b = sizeof(b)/sizeof(b[0]);
int i,j,flag;

//sort(a)
sort(a, len_a);
cout << "sort(A):" << endl;
print_array(a,len_a);

//sort(b)
sort(b, len_b);
cout << "sort(B):" << endl;
print_array(b, len_b);

//A-B
int c[max]={0};
int k=-1;
for (i=0; i < len_a; i++)
{
flag = 0;
for (j=0; j < len_b; j++)
{
if (a[i] == b[j]) flag = 1;
if (flag == 1) break;
}
if(flag == 0) c[++k] = a[i];
}

int len_c = k+1;
cout << "A-B:" <<endl;
print_array(c, len_c);

//B-A
int d[max]={0};
k=-1;
for (i=0; i < len_b; i++)
{
flag = 0;
for (j=0; j < len_a; j++)
{
if (b[i] == a[j]) flag = 1;
if (flag == 1) break;
}
if(flag == 0) d[++k] = b[i];
}
int len_d = k+1;
cout << "B-A:" <<endl;
print_array(d, len_d);

//A intersection B
int f[max];
k = -1;
for(i=0; i <= len_a; i++)
{
flag = 0;
for (j=0; j <= len_b; j++)
{
if(b[j] == a[i]) flag = 1;
}
if(flag == 1) f[++k] = a[i];
}

cout << "A intersection B:" <<endl;
print_array(f, k+1);

//union(A-B,B-A)=union(c,d)
int e[max];
k = -1;
for(i=0; i < len_c; i++)
{
e[++k] = c[i];
}
for(i=0; i < len_d; i++)
{
e[++k] = d[i];
}

cout << "union(A-B,B-A)" <<endl;
print_array(e, k+1);

//union(A,B)=union(A-B,B)
int g[max];
k = -1;
for (i=0; i < len_c; i++)
{
g[++k] = c[i];
}
for(i=0; i < len_b; i++)
{
g[++k] = b[i];
}

cout << "union(A,B):" <<endl;
print_array(g, k+1);
}

⑸ 怎样对数组进行交集与并集运算

数组的并集
给定两个数组：
int[] a = {1, 2, 3, 4, 5};
int[] b = {2, 3, 5, 6, 7};
输出：
1,2,3,4,5,6,7
我的思路：
两个数组的交集第一时间想到的肯定是最简单的两两比较，如果相等就加进新数组，但是这样做会造成时间的大量浪费，如果两个长度各1W的数组，比较完的时间….不可想象。
然后马上就想到Java的HashSet,重复不添加，所以把所有的数组遍历进Set,再遍历Set岂不是就完成了。
于是很容易实现了我的代码：
int[] a = {1, 2, 3, 4, 5}; int[] b = {2, 3, 5, 6, 7};
HashSet<Integer> hashSet = new HashSet<>(); for (int aNum : a) {
hashSet.add(aNum);
} for (int bNum : b) {
hashSet.add(bNum);
}
Iterator<Integer> iterator = hashSet.iterator(); while(iterator.hasNext()){
System.out.print(iterator.next()+" ");
}

数组的交集
给定两个数组：
int[] a = {1, 2, 3, 4, 5};
int[] b = {2, 3, 5, 6, 7};
输出：
3,4,5
我的思路：与之前相同，强行跑遍历的算法肯定是不可取的，又想到了之前在一堆有重复数的数组中找出唯一一个没有重复的算法：
一是看到的最优解对自身进行^运算。
二是自己思考出的通过HashMap对每个数进行个数统计，如果为1则得出。
同理得出此处交集的运算规则，统计每一个数的出现次数，如果为2，则是交集。
以下为代码实现：
int[] a = {1, 2, 3, 4, 5}; int[] b = {2, 3, 5, 6, 7};
HashMap<Integer, Integer> hashMap = new HashMap(16); for (int i = 0; i < a.length; i++) { if (hashMap.get(a[i]) != null) {
hashMap.put(a[i], hashMap.get(a[i]) + 1);
} else {
hashMap.put(a[i], 1);
}
} for (int i = 0; i < b.length; i++) { if (hashMap.get(b[i]) != null) {
hashMap.put(b[i], hashMap.get(b[i]) + 1);
} else {
hashMap.put(b[i], 1);
}
} for (int i : hashMap.keySet()) { if (hashMap.get(i).equals(2)) {
System.out.print(i+" ");
}
}
}

⑹ 并集和交集的公式是什么

交集？并集？

你还记得高中数学的第一课吗？讲的是集合，具体定义去网络，里面有两个运算法则：交集和并集。也许你当时觉得很容易，那么今天还是回头想想它在讲什么。

一、两个集合

一切运算都是两个相对的集合间的关系法则，既然是高中数学，那么就略谈一下教育，其实很多人会说“你考好了说明学好了”，然而我想说的是考试和教学是两个集合。

我们看看中国过去的八股文，包括今天的高考，受到那么多诟病，但是为什么还是继续这么做？因为相关部门不知道，无作为？我觉得要是从另外一个角度看，考试作为一种人才选拔的工具，那选拔什么样的人呢？是见多识广、才华横溢的人；还是那些面对一个目标，能持之以恒地找方法达成，坐得住、能下功夫的人呢？

不好意思，答案很可能是后者。

现在很多创业公司都有这样的体会。招人的时候，他们往往不是倾向于招那些有经验的人，而倾向学习能力好、沟通能力强、对自己要求严、有自我驱动能力的人。因为创业公司本来做的就是全新的事情，经验这个东西是有益还是有害，说不清楚。但是面对任何新的情况，都能找到方法、诉诸行动、不丢目标的人，才是创业公司需要的。前一阵还有一位创业公司的创始人跟我说，他发现优秀的大学生，比行业里的老鸟好用。

这种优秀的人，不管面对什么样的题目，哪怕是八股文，也一样可以坐得住、下苦功，最后考出好成绩。这样的人走入仕途，面对自己不熟悉的任务，也一样会表现优秀。事实上，明清两代那么多能人都是靠八股文选拔出来的，比如我们熟悉的王阳明和曾国藩。

再回头来说我们的高考。

这几年，高考的发展趋势和八股文正好相反的，这也是很多人呼吁和推动的结果。各地高考越来越强调地方特色，越来越多地考核学生的所谓“综合素质”。这种发展方向看似正确，但是也有值得反思的地方。

首先，中国是一个大国，各地情况差异巨大，社会阶层也差异巨大。只有坚持全国的统一性，才能确保人才通过高考在全国范围内的流动和交流，维持整个国家的内在联系和国家认同。不夸张地说，如果高考的全国统一性消失了，中国各个地方的内在联系会被严重削弱。

我们不能把高考仅仅看作是教育的一个环节，高考是国家治理中的关键，事关国家的完整统一和治理水平。

其次，虽然不必恢复到八股文那样死板的形式，但高考仍然要尽量维持简单、明晰的考试内容和形式。一言以蔽之，永远要确保，学生只靠几本教科书、只比拼硬功夫、笨功夫就能取得好成绩。

和科举一样，高考不是教育工具，高考是人才选择的工具。它把各个社会阶层里奋发向上，能坐得住、下苦功夫的人挑选出来，保持这个社会的活力和公平。这才是高考在当前中国社会的真实作用。

然而，所谓教育则是一种能力的培养，一种思维模式的锻炼，比如我们讲集合，你不光会做题还要会应用，比如将学习数学思维和考试分开来，当然它们之间有交集，就是你既能坐下来刷题总结，又能进行发散和转化，你要既能学好集合又能考好集合这就是交集，而你只是明白自己要好好学习并且考试优异这就是并集。其实大多数人在看问题的时候喜欢用并集，这样比较省事，也符合原始的认知方式，然而今天这种方式与时代有所不匹配啦，这种人就是那些现在边缘只求安全感，却不愿多向集合内多走一步深入了解的人。我们在许多问题上可以有所区分，比如人工智能就是未来一切的引导？关系问题一定是其中一个人有问题或者两个人有问题？

二、人工智能就是人类的全部模拟？

这个的答案明显是否定的，人工智能是完全通过算法运行的，这些算法都来自于各个学科的模型计算，你去翻翻书，所以学科都有一个所谓的理想假设，这个假设通俗的讲就是，如果世界只有XX学科来指导运行的话。所以人工智能可以模拟任意学科，但是这是不同的集合，交集并不能完全模拟，对于这个问题，很多人认为只要融合了那么交集自然呈现啊，其实不然。举个例子，一些有经验的心理咨询师在处理感情纠葛问题时，会说他面对的是三个人，夫妻双方和他们的关系，而关系就是交集的结果，所以关系问题不一定是个人或者两个人的问题导致，也有可能是他们的交集，也就是产生的关系导致。再者人工智能更偏向科学，而科学思维和技术仅仅是社会中的小部分，还有大部分的人性，也就是社会科学，例如人工智能的围棋站，输的那一局就是输在人性上，所以任何复杂问题回答时，可以考虑下是否存在两个及以上集合，因为可能存在第三者。（上述问题因本文需求，不多做拓展）这样一个是非问题只有两个答案，却可能有三层认知。

三、认知三级跳

最近中子星的新闻应该都看过了，那么问个看问题，宇宙是有限的还是无限的？如果回答宇宙是有限大的，那说明这个人具备了一定的科学素养。如果他回答宇宙是无限大的，那就有两种可能。一种可能是这个人对现代科学一无所知；另一种可能，却是他对天体物理学的最新进展非常了解。

第一层，无限大，从小就知道宇宙浩瀚无边，没有天边，所以无限大。

第二层，有限大，知道宇宙大爆炸，就知道宇宙是个正在被吹大得气球，不管怎么变大，气球总还是有边界的，于是有限大。

第三层，无限大，根据2013最新发现，宇宙质能比例系数为1±0.004，以及宇宙背景辐射的数据，证明在欧几里得空间内，宇宙是一个平面，无限延伸。

那么又会出现一个特别有意思的情况，二八理论，如果去统计下会发现中间层的人会有80%，所以当你和很多别人的观点一样的时候就要警惕啦，你是不是中间层？你也许离出现集合只有一步，而你却沾沾自喜。

同样的事情我们看看对朋友圈的认识，最早用的时候，很多人不习惯的，认为不好所以希望不要有。当发现里面信息多样化，被设计吸引后，几乎大多数人都爱它。而像我自从写出那篇朋友圈是黑暗森林后，至今朋友圈没看过，而我并没有过不下去，或者对我的生活学习工作没有太大影响，那我还去看了干嘛，花去巨大的时间成本，却基本没有收益啊。

⑺ EXCEL 如何进行“并集“和“交集“运算

交集，用公式countif查找a列各值，在b列中出现的次数，筛选出次数为1的单元格，即为交集
如筛选出次数为0的单元格，则是a-b（差集）
并集，将第二列数据，复制到第一列的最后一行数据的下面，点击”数据“，删除重复项，即得到并集。

⑻ 大数据量的交集，并集，差集求解算法

首先这点数据并不大呀。。
交集最好做 [hash]/[单排序+二分]/[双排序+归并过程找]
并集同理，只不过把交集中不要的数据也记录下来就行了
差集，只要交集过程中不要的

⑼ 集合运算的算法

并集和交集差不多。这里只说下思想（太懒了我）。感觉用单链表实现比较方便。
并集：首先定义好存储数组的结构体，包括数组的值和指向下一元素的指针。当用户每输入一个数组，则从堆分配一段空间给这个数组，然后将地址作为此集合数组的头指针，构建这个集合的单链表，当然构建时注意排序，就是值小的往前插，值大的往后插。全部集合构建完后，利用两个指针在先将第二个集合插入第一个集合中（寻找第二个集合不同于第一个集合的元素，插进第一个元素，全部插入后，删除第二个的头指针），依次进行，直到合并所有集合。然后从第一个元素往后输出就是。
交集：与并集差不多，只是合并时只保留两个集合相同的元素，删掉其余元素。