在数据结构书上看到了求集合的交集和并集的运算的算法，心里就想着写写，但是之前一直没时间，今天趁着周末就就把它解决了。其实交集非常简单的，就是并集想了下子。唉，没办法，技术有限。
code：

#include<stdio.h>
#define MAXN 1000

void jiaoji(int a[], int b[], int p, int q)
{
    int k = 0;
    int c[MAXN];
    for(int i = 0; i < p; i++)
    {
        for(int j = 0; j < q; j++)
        {
            if(a[i] == b[j])
                c[k++] = a[i];
        }
    }
    for(int m = 0; m < k; m++)
        printf("%d ", c[m]);
    printf("\n");
}

void bingji(int a[], int b[], int p, int q)
{
    int array[MAXN], c[MAXN];
    int k = 0;
    for(int i = 0; i < p; i++)
    {
        for(int j = 0; j < q; j++)
        {
            if(a[i] == b[j])
                array[i] = 1;
        }
    }
    for(int m = 0; m < p; m++)
    {
        if(array[m] != 1)
            c[k++] = a[m];
    }
    for(int n = 0; n < q; n++)
        c[k++] = b[n];
    for(int m = 0; m < k; m++)
        printf("%d ", c[m]);
    printf("\n");
}

int main()
{
    int _a[MAXN], _b[MAXN];
    int l_1,l_2;
    while(scanf("%d%d", &l_1, &l_2) != EOF)
    {
        for(int i = 0; i < l_1; i++)
            scanf("%d", &_a[i]);
        for(int j = 0; j < l_2; j++)
            scanf("%d", &_b[j]);

        jiaoji(_a, _b, l_1, l_2);
        bingji(_a, _b, l_1, l_2);
    }
    return 0;
}


听说集合还有其他的运算，以后再看看吧。

解题思路（单链表求交集、并集、差集的思想和顺序表求交集、并集、差集的思想基本相同）
1.先通过CreateListR 函数将集合 a 和 b 中的元素添加到顺序表 ha 和 hb 中 ，添加过程使用的是顺序表原有的Initlist 函数（初始化表） 和 ListInsert 函数 （向表中插入元素）  。
2.因为原集合是无序的， 所以我通过 sort 函数 （选择排序），使得集合变得有序。
3.得到有序集合 ha 和 hb 后， 便可以使用 Union 函数（类似归并的思想写出来的求并集的函数），求出 ha 和 hb 的并集。
4.而求交集的方法则是， 通过将 集合 a 中的元素一个一个取出，并通过 函数LocateElem ，查看集合 hb 中是否存在该元素，如果存在则将 元素放入 hc ，如果不存在，则舍去。 以此求得 两 集合的交集。
5.求两集合的差 则可以反过来，同样通过将 集合 a 中的元素一个一个取出，并通过 函数LocateElem ，查看集合 hb 中是否存在该元素，如果不存在则将 元素放入 hc ，如果存在，则舍去。 以此求得两集合的差集。

#include <iostream>
#include <cstdio>
#include <malloc.h>
using namespace std;

/* 定义单链表数据 */
typedef char ElemType;
typedef struct LNode
{
    ElemType data;
    struct LNode *next;
}LinkList;

/* 单链表的初始化 */
void InitList(LinkList *&L)
{
    L = (LinkList *)malloc(sizeof(LinkList));
    L->next=NULL;
}

/* 向单链表中插入数据元素 */
bool ListInsert(LinkList *&L,int x,char e)
{
    int j = 0;
    LinkList *p = L, *s;
    while(p!=NULL && j<x-1)
    {
        p = p->next;
        j++;
    }
    if(p==NULL)
    {
        return false;
    }
    else
    {
        s = (LinkList *)malloc(sizeof(LinkList));
        s->data = e;
        s->next = p->next;
        p->next = s;
        return true;
    }
}

/* 输出单链表 */
void DispList(LinkList *L)
{
    LinkList *p = L->next;
    while(p!=NULL)
    {
        printf("%c ",p->data);
        p = p->next;
    }
    printf("\n");
}

/* 求单链表的长度 */
int ListLength(LinkList *L)
{
    LinkList *p = L->next;
    int i = 0;
    while(p!=NULL)
    {
        i++;
        p = p->next;
    }
    return i;
}

/* 查看单链表是否为空 */
bool ListEmpty(LinkList *L)
{
    return L->next==NULL;
}

/* 求单链表中某个数据元素值 */
bool GetElem(LinkList *L,int i, ElemType &e)
{
    LinkList *p = L;
    int j = 0;
    while(p!=NULL && j < i)
    {
        p=p->next;
        j++;
    }
    if(p==NULL)
    {
        return false;
    }
    else
    {
        e = p->data;
        return true;
    }
}

/* 在单链表中查找元素 */
int LocateElem(LinkList *L,ElemType e)
{
    LinkList *p = L;
    int i = 0;
    while(p!=NULL && p->data!=e)
    {
        p = p->next;
        i++;
    }
    if(p==NULL)
    {
        return 0;
    }
    else
    {
        return i;
    }
}

/* 删除单链表中第 i 个元素*/
bool ListDelete(LinkList *&L,int i,ElemType &e)
{
    int j = 0;
    LinkList *p = L, *q;
    while(p!=NULL && j < i - 1)
    {
        p = p->next;
        j++;
    }
    if(p==NULL)
        return false;
    else
    {
        q = p->next;
        if(q==NULL)
            return false;
        e = q->data;
        p->next = q->next;
        free(q);
        return true;
    }
}

/* 删除单链表 */
void DestroyList(LinkList *&L)
{
    LinkList *p = L;
    LinkList *q = p->next;
    while(q!=NULL)
    {
        free(p);
        p = q;
        q = p->next;
    }
    free(p);
}

void CreateListR(LinkList *&L,ElemType e[],int n)
{
    InitList(L);
    int i;
    for(i = 0;i < n; ++i)
    {
        if(!LocateElem(L,e[i]))
            ListInsert(L,i+1,e[i]);
    }
}

void InsterSect(LinkList *a,LinkList *b,LinkList *&c)
{
    DestroyList(c);
    InitList(c);
    LinkList *p = a->next;
    int i = 0;
    while(p!=NULL)
    {
        if(LocateElem(b,p->data))
            ListInsert(c,++i,p->data);
        p = p->next;
    }
}

void Subs(LinkList *a,LinkList *b,LinkList *&c)
{
    DestroyList(c);
    InitList(c);
    LinkList *p = a->next;
    int i = 0;
    while(p!=NULL)
    {
        if(!LocateElem(b,p->data))
            ListInsert(c,++i,p->data);
        p = p->next;
    }
}

void Union(LinkList *a,LinkList *b,LinkList *&c)
{
    InitList(c);
    LinkList *p = a->next;
    LinkList *q = b->next;
    int k = 0;
    while(p!=NULL && q!=NULL)
    {
        if(p->data < q->data)
        {
            ListInsert(c,k+1,p->data);
            p = p->next;
            k++;
        }
        else if(p->data == q->data)
        {
            ListInsert(c,k+1,p->data);
            p = p->next;
            q = q->next;
            k++;
        }
        else
        {
            ListInsert(c,k+1,q->data);
            q = q->next;
            k++;
        }
    }
    while(p!=NULL)
    {
        ListInsert(c,k+1,p->data);
        p = p->next;
        k++;
    }
    while(q!=NULL)
    {
        ListInsert(c,k+1,q->data);
        q  = q->next;
        k++;
    }
    ///cout<<"hehe"<<endl;
}

void sort(LinkList *&L)
{
    LinkList *p , *pre, *q, *k;
    InitList(p);
    int i = 0;
    char c;
    while(!ListEmpty(L))
    {
        pre = L ->next;
        c = pre->data;
        while(pre!=NULL)
        {
            if(c>=pre->data)
                c = pre->data;
            pre = pre->next;
        }
        ListInsert(p,++i,c);
        int tag = LocateElem(L,c);
        ListDelete(L,tag,c);
    }
    L = p;
}


int main( )
{
    LinkList *ha, *hb, *hc;
    ElemType a[]={'c','a','e','h'};
    ElemType b[]={'f','h','b','g','d','a'};
    printf("集合的运算如下\n");
    CreateListR(ha,a,4);
    CreateListR(hb,b,6);
    printf("原 集 合 A: "); DispList(ha);
    printf("原 集 合 B: "); DispList(hb);
    sort(ha);
    sort(hb);
    printf("有序集合A："); DispList(ha);
    printf("有序集合B："); DispList(hb);
    Union(ha,hb,hc);
    printf("集合的并C："); DispList(hc);
    InsterSect(ha,hb,hc);
    printf("集合的交C："); DispList(hc);
    Subs(ha,hb,hc);
    printf("集合的差C："); DispList(hc);
    DestroyList(ha);
    DestroyList(hb);
    DestroyList(hc);
    return 0;
}

 
转载于:https://www.cnblogs.com/mengqimoli/p/8604770.html

# 集合 Python除了List、Tuple、Dict等常用数据类型外，还有一种数据类型叫做集合（set），
# 集合的最大特点是：集合里边的元素是不可重复的并且集合内的元素还是无序的，所以一般情况下集合常用的两个场景是：
# 1.去重（如：列表去重）；2.关系测试（如：取交集、取并集、取差集等）

# 创建集合  注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
# 第一种方法 直接使用{}创建  不推荐
numberset = {1, 2, 5, 3, 3, 4, 5}  # 直接使用{}创建元组  # 如果输入了重复的元素，python会自动只保留一个
threeset = {"醉里挑灯看剑", "梦回吹角连营", "八百里分麾下炙", "五十弦翻塞外声", "沙场秋点兵"}
fourset = {"Python", 28, ("人生苦短", "我要用python"), ("爬虫", "云计算", "大数据")}
themeset = {"优雅", "大方", "美丽"}
print(numberset, "\n", threeset, "\n", fourset, "\n", themeset)  # python中的set是无序的，所以每次输出时元素的排序可能不同
# 第二种方法 使用set()函数创建   将列表、元组和其他可以迭代的对象转换成集合
# 语法：setname = set(iteratiom)  iteratiom:要转换为集合的可迭代对象，包含列表、元组、range对象等，也可以是字符串（返回的集合将是包含全部不重复字符的集合）
set1 = set([1, 2, 3, 4])
# 创建一个字符集合  注意：从输出结果中我们会看到l只出现了一次
set2 = set("Hello，World!")
set3 = set(("人生苦短", "我要用python"))
set4 = set(range(2, 5))
set5 = set()  # 空集合
print(set1, set2, set3, set4, set5)

# 向集合中添加和删除元素
# 添加元素  add()方法  set.add(element) element：表示要添加的元素内容（只能使用字符串、数字和布尔类型的数据，不可以使用列表、元组等迭代对象）
set6 = {"醉里挑灯看剑", "梦回吹角连营", "八百里分麾下炙", "五十弦翻塞外声", "沙场秋点兵"}
set6.add("这是刘禹锡的诗句")  # add()方法
print(set6)
# 还有copy()方法  直接复制集合
set7 = set6.copy()
print(set7)
# 删除集合元素 四种方法：del  pop() remove() clear()
set8 = {"醉里挑灯看剑", "梦回吹角连营", "八百里分麾下炙", "五十弦翻塞外声", "沙场秋点兵"}
set8.remove("醉里挑灯看剑")  # s.remove(x) 删除指定元素，将元素x从集合s中移除，如果元素不存在，则会发生错误。
print("remove()方法后：", set8)
obj1 = set8.pop()  # 删除一个元素
print("移除的元素是：", obj1, "pop()方法后：", set8)
set8.clear()  # clear()方法清空集合
print("clear()方法后：", set8)
del set8  # del语句会删除整个集合
# print("clear()方法后：", set8)

# 计算集合元素个数 语法格式如下：len(s) 计算集合 s 元素个数。
set9 = set(("醉里挑灯看剑", "梦回吹角连营", "八百里分麾下炙", "五十弦翻塞外声", "沙场秋点兵"))
print("集合元素的是个数：", len(set9))
# 判断元素是否在集合中存在 语法格式如下：x in s 判断元素x是否在集合s中，存在返回 True，不存在返回 False。
print("八百里分麾下炙" in set9)
print("小巧你在哪" in set9)

# 集合的交集、并集和差集运算
set1 = set([1, 2, 5, 4, 3, 6])
set2 = set([3, 4, 5, 6, 7, 8])
# 取交集 &
set3 = set1 & set2
set3 = set1.intersection(set2)  # 取交集，intersection()与 & 效果相同
print("set1和set2的交集(set1 & srt2)为：", set3)
# 取并集 |
set4 = set1 | set2
# set4 = set1.union(set2)  #取并集，union()与 | 效果相同
print("set1和set2的并集(set1 | srt2)为：", set4)
# 取差集
set5 = set1 - set2
# set5 = set1.difference(set2)  #取差集 ,difference()与 - 效果相同
print("set1与set2的差集(set1 - srt2)为：", set5)
set6 = set2 - set1
# set6 = set2.difference(set1)
print("set2与set1的差集为：", set6)
# 对称差集 即去掉两个集合的共同的部分
set7 = set1 ^ set2
set7 = set1.symmetric_difference(set2)  # 对称差集, symmetric_difference()与 ^ 效果相同
print("set1 ^ set2(去掉两个集合的共同的部分)=", set7)
# 判断是否是set1是否是set2的子集
flag1 = set1.issubset(set2)
print("判断是否是set1是否是set2的子集：", flag1)
# 判断是否是set1是否是set2的父集
flag2 = set1.issuperset(set2)
print("判断是否是set1是否是set2的父集：", flag2)

 

集合：

集合是无序可变，元素不能重复。实际上集合底层是字典实现，集合的所有元素都是字典中的“键对象”，因此是不能重复的且唯一的。

集合的创建与删除：









集合相关操作：