精华内容
下载资源
问答
  • 计算集合的交集和并集

    千次阅读 2012-09-16 13:05:00
    在数据结构书上看到了求集合的交集和并集的运算的算法,心里就想着写写,但是之前一直没时间,今天趁着周末就就把它解决了。其实交集非常简单的,就是并集想了下子。唉,没办法,技术有限。 code: #include #...

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

    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 函数...

    解题思路(单链表求交集、并集、差集的思想和顺序表求交集、并集、差集的思想基本相同)

    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

    展开全文
  • 2.关系测试(如:取交集、取并集、取差集等) # 创建集合 注意:创建一个空集合必须用 set() 而不是 { },因为 { } 是用来创建一个空字典。 # 第一种方法 直接使用{}创建 不推荐 numberset = {1, 2, 5, 3, 3.
    # 集合 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)

     

    展开全文
  • 集合: 集合是无序可变,元素不能重复。实际上集合底层是字典实现,集合所有元素都是字典中“键对象”,因此是不能重复且唯一。 集合创建与删除: 集合相关操作: ...

    集合:

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

    集合的创建与删除:

    集合相关操作:

     

     

     

     

     

    展开全文
  • 用线性表实现集合的求交集和并集的运算 (*^__^*)
  • 我们在遇到一些问题时候,使用集合的交集并集和差集能够更便捷帮助我们去解决问题,看下面一个例子。某学校有两个班级,班级A需要学习数学、语文、英语、物理、化学生物,班级B需要学习数学、语文、英语、...
  • 在常规自定义函数的世界中,一般情况下,仅会输入一堆的参数,最终输出一个结果值,在以往Excel催化...使用场景在数据库环境、编程环境中,大量的使用集合的概念,两个集合之间的运算有以下五种情况,今天Excel催化...
  • 集合创建删除 1. 使用{}创建集合对象,并使用 add()方法添加元素 >>> a = {3,5,7} >>> a {3, 5, 7} >>> a.add(9) >>> a {9, 3, 5, 7} 2. 使用 set(),将列表、元组等...
  • 集合 ...集合创建删除 //--------------------练习---------------- 2. //--------------练习----------------------------- 3. //------------------练习----------------- 集合相关操作
  • Matlab中向量的交集并集、差集等集合运算

    万次阅读 多人点赞 2017-12-30 19:31:04
    intersect(A, B):集合交集,AB均为向量 union(A, B) :集合并集 setdiff(A, B) :集合A减集合B差集(如果集合A中元素都在B中存在,则结果为空) ismember(a, A) :判断是否是集合中元素 sort(A):对向量进行...
  • 第53课时: 集合 {} 特点 创建删除 交集并集差集运算 集合: 集合是无序可变 ,元素不能重复, 集合底层实现就是字典,只不过只有键对象,没有值对象。 集合创建删除: 1使用{}创建集合对象,并使用add...
  • 理解两个集合交集并集的概念性质 求两个集合的交集与并集常用方法-——数轴法图示法. 观察集合A,B,C元素间的关系: A={4,5,6,8} ,B={3,5,7,8} ,C={3,4,5,6,7,8} A={x|x是有理数},B={x|x是...
  • 定义域是这两个函数交集还是并集是交集。因为要满足定义域中任意x在y中都有一个唯一确定值(而这个y是对于两个函数y,如果是并集会导致某个... 交集和并集运算结果是集合,集合是表示定义域方法 但是要注意...
  • 今天突然想用Java实现如何用集合实现交集并集和差集的运算了!主要是看Python语言的时候想起来的。 实现主要使用的Set集合,Set集合的特点是集合内的元素不可重复。 具体代码如何: 1 package ...
  • 【实验目的】掌握用计算机求集合交、并、差运算的方法。 【实验内容】编程实现集合交、并、差运算。 【实验原理方法】 (1)用数组A,B,C,E表示集合。输入数组A,B,E(全集),输入数据时要求...
  • Oracle 中求结果集中的交集和并集

    千次阅读 2007-05-29 14:52:00
    在Oracle中,有两个运算符很重要:intersectminusintersect运算:返回查询结果中相同部分(交集)minus运算:返回在第一个查询结果中与第二个查询结果不相同那部分行记录。(并集
  • P50:集合-特点-创建删除-交集并集差集运算集合是无序可变,元素不能够重复,实际上,集合底层是字典实现,集合所有元素都是字典当中键对象,因此不能够重复并且是唯一。集合创建删除使用{}创建集合...
  • 本文采用一种交换方式来求出两个数组的并集交集和差集,这种算法运算速度较快,内存消耗空间较少,是一个值得学习好方法,另外,作者提醒您,重要不是算法本身,而是该算法会开拓我们思维空间,要注意对...
  • //包括进行集合的并集交集差集 #include #include //INT_MIN using namespace std; class C_iSet{ private: int max_size; int cur_size; int *Pdata; public: C_iSet(C_iSet & SetA)
  • ...union/union all运算:将查询返回组合成一个结果,&nbsp;union all不过滤重复。 SELECT product_id FROM order_itemsUNIONSELECT product_id FROM inventories; SELECT location_id...
  • INTERSECT (交集),返回两个查询共有记录。【A∩B 只取AB相同部分,只取一次】 UNION ALL (并集),返回各个查询所有记录,包括重复记录。【如 A∪+ B 取AB所有信息,相同部分各取一次】 ...
  • Stream 使用一种类似用 SQL 语句从数据库查询数据直观方式来提供一种对 Java 集合运算和表达高阶抽象。Stream API可以极大提高Java程序员生产力,让程序员写出高效率、干净、简洁代码。这种风格将要处理...
  • 如果没接触过,请看这里简单介绍:交集set_intersection、并集set_union、差集set_difference、对称差集set_symeetric_difference。  针对这里提及四个集合运算必须特别注意: 1、第一个算法需保证第一集合...
  • 并集和交集运算结果,与先后顺序无关; c) 差集运算;minus; i. a-b; ii. b-a; 1 复制表结构; 复制表追加主键约束; 更新一行记录 ; create table b as select * from a where 1 &lt;&gt;1; ...
  • Python set 集合最常用操作是向集合中添加、删除元素,以及集合之间做交集并集、差集等运算,本节将一一讲解这些操作具体实现。 向 set 集合中添加元素 set 集合中添加元素,可以使用 set 类型提供 add() ...
  • 集合对象还支持union(联合), intersection(交), difference(差)sysmmetric difference(对称差集)等数学运算. sets 支持 x in set, len(set), for x in set。作为一个无序集合,sets不记录元素位置或者插入点...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 545
精华内容 218
关键字:

交集和并集的运算