並集插演算法

⑴ 集合的交集與並集

【補充：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]/[單排序+二分]/[雙排序+歸並過程找]
並集同理，只不過把交集中不要的數據也記錄下來就行了
差集，只要交集過程中不要的

⑼ 集合運算的演算法

並集和交集差不多。這里只說下思想（太懶了我）。感覺用單鏈表實現比較方便。
並集：首先定義好存儲數組的結構體，包括數組的值和指向下一元素的指針。當用戶每輸入一個數組，則從堆分配一段空間給這個數組，然後將地址作為此集合數組的頭指針，構建這個集合的單鏈表，當然構建時注意排序，就是值小的往前插，值大的往後插。全部集合構建完後，利用兩個指針在先將第二個集合插入第一個集合中（尋找第二個集合不同於第一個集合的元素，插進第一個元素，全部插入後，刪除第二個的頭指針），依次進行，直到合並所有集合。然後從第一個元素往後輸出就是。
交集：與並集差不多，只是合並時只保留兩個集合相同的元素，刪掉其餘元素。