离散数学：求集合的并、交、差、环和（c语言链表实现）

最新推荐文章于 2024-07-22 20:42:27 发布
最新推荐文章于 2024-07-22 20:42:27 发布
阅读量4.8k 收藏 70
点赞数 19
文章标签： c语言 链表 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53621849/article/details/121548405
版权

题目描述：

        给定两个集合A，B，求其并、交、差、环和。

输入格式：

       输入分为两行，第一行输入集合A,第二行输入集合B, 其中各包括若干个元素,每个元素用“，”隔开，用“{}”表示空集。元素按照字典序排列。

输出格式：

        输出分为4行，第一行输出A∪B的集合，第二行输出A∩B的集合，第三行输出A-B的集合，第四行输出A⊕B的集合。元素按照字典序排列。

输入样例：

              {a,b,c,d}

              {c,d,e,f}

输出样例：
              {a,b,c,d,e,f}

              {c,d}

              {a,b}

              {a,b,e,f}

概念：

        1.设A，B为集合，A与B的并集A∪B，交集A∩B，B对A的相对补集A-B分别定义如下：

    A∪B={x|x∈A\/x∈B}；

 A∩B={x|x∈A/\x∈B}；

A-B={x|x∈A/\x∉B}

        2.设A，B为集合，则A与B的对称差是

A⊕B=(A-B)∪(B-A)

        A与B的对称差还有一个等价的定义，即

A⊕B=(A∪B)-( A∩B)

思路：

首先定义一个结构体

#define MAXSIZE 100
typedef struct Collection{
    char c;  // 表示集合中的元素
    struct Collection *next;
}*collection;

从输入的字符串中获得元素，顺便返回元素个数，获得只有元素的数组

int createmember(char *x,char *y)
{
    char *c=x;
    int num=0;
    while(*c)
    {
        if ((*c>='a'&&*c<='z')||(*c>='A'&&*c<='Z')||(*c>='0'&&*c<='9'))
        {
            *y=*c;
            y++;
            num++;
        }
        c++;
    }
    return num;
}

 题目上说输入时元素按字典序排列，但也可以自己再排序，可有可无（选择排序）

void sort(char x[MAXSIZE],int len)
{
    int min=0;
    for(int i=0;i<len;i++)
    {
        int start=i;
        min=start;
        while(start<len)
        {
            if (x[start]<x[min])
                min=start;
            start++;
        }
        char c=x[i];
        x[i]=x[min];
        x[min]=c;
    }
}

对集合链表进行初始化

collection init(collection c)
{
    c=(collection)malloc(sizeof(struct Collection));
    c->next=NULL;
    return c;
}

将输入的集合元素的字符串转换为链表

collection createinit(collection c,char z[MAXSIZE],int n)
{
    collection p=c;
    for(int i=0;i<n;i++)
    {
        collection q=(collection)malloc(sizeof(struct Collection));
        q->c=z[i];
        p->next=q;
        p=q;
    }
    p->next=NULL;
    return c;
}

计算并集

collection bing(collection b,char x[MAXSIZE],char y[MAXSIZE])
{
    int flag=0;  // 判断元素是否相等的标志
    createinit(b,x,n1);
    collection p1=b->next;
    for(int i=0;i<n2;i++)
    {
        while(p1!=NULL)
        {
            if (y[i]==p1->c)
            {
                flag=1;
                break;  // A与B的元素要是相等就退出，遍历下一个A集合的元素
            }
            p1=p1->next;
        }
        p1=b->next;
        if (flag==0)
        {
            collection q=(collection)malloc(sizeof(struct Collection));
            q->c=y[i];
            if (p1==NULL)  // A集合有可能是空集
            {
                b->next=q;
                q->next=NULL;
            }
            else
            {
                while (p1!=NULL)
                {
                    if (q->c<p1->c)  // B集合要插入的元素比A集合所有的元素都小
                    {
                        q->next=p1;
                        b->next=q;
                        break;
                    }
                    else if (q->c>=p1->c)
                    {
                        if (p1->next!=NULL&&q->c<p1->next->c)  // 要插入的位置在中间
                        {
                            q->next=p1->next;
                            p1->next=q;
                            break;
                        }
                        else if (q->c>=p1->c&&p1->next==NULL)  // 要插入的位置在最后
                        {
                            p1->next=q;
                            p1=q;
                            p1->next=NULL;
                        }
                    }
                    p1=p1->next;
                }
            }
        }
        flag=0;  // 重置存在标志
    }
    return b;
}

计算交集

collection jiao(collection j,char x[MAXSIZE],char y[MAXSIZE])
{
    collection j1=init(j1),j2=init(j2);
    createinit(j1,x,n1);
    createinit(j2,y,n2);
    collection p=j,p1=j1->next,p2=j2->next;
    while (p1!=NULL)
    {
        while(p2!=NULL)
        {
            if (p1->c==p2->c)  // 要是元素相等就加入集合
            {
                collection q=(collection)malloc(sizeof(struct Collection));
                q->c=p1->c;
                p->next=q;
                p=q;
            }
            p2=p2->next;
        }
        p1=p1->next;
        p2=j2->next;
    }
    p->next=NULL;
    clear(j1);
    clear(j2);
    return j;
}

计算相对补集

collection cha(collection c,char x[MAXSIZE],char y[MAXSIZE])
{
    int flag=0;  // 判断元素是否相等的标志
    collection c1=init(c1),c2=init(c2);
    createinit(c1,x,n1);
    createinit(c2,y,n2);
    collection p=c,p1=c1->next,p2=c2->next;
    while (p1!=NULL)
    {
        while(p2!=NULL)
        {
            if (p1->c==p2->c)
            {
                flag=1;
                break;
            }
            p2=p2->next;
        }
        if (flag==0)  // A集合中存在而B集合中不存在
        {
            collection q=(collection)malloc(sizeof(struct Collection));
            q->c=p1->c;
            p->next=q;
            p=q;
        }
        p1=p1->next;
        p2=c2->next;
        flag=0;  // 重置元素相等标志
    }
    p->next=NULL;
    clear(c1);
    clear(c2);
    return c;
}

计算对称差（利用第二个等价定义）

collection huan(collection h,collection j,char x[MAXSIZE],char y[MAXSIZE])
{
    collection h1=init(h1),h2=j->next,p,q,r;
    h1=bing(h1,x,y);
    p=h1;
    q=h1->next;
    while(h2!=NULL)
    {
        while(q!=NULL)
        {
            if (h2->c==q->c)
            {
                r=q;
                q=q->next;
                p->next=q;
                free(r);
                break;
            }
            else
            {
                q=q->next;
                p=p->next;
            }
        }
        h2=h2->next;
    }
    h=h1;
    return h;
}

完整代码：

#include <stdio.h>
#include <stdlib.h>
#define MAXSIZE 100
int n1=0,n2=0;
typedef struct Collection{char c;struct Collection *next;}*collection;
void clear(collection c)
{
    collection p=c->next,q;
    while(p!=NULL)
    {
        q=p;
        p=p->next;
        free(q);
    }
    c->next=NULL;
}
void sort(char x[MAXSIZE],int len)
{
    int min=0;
    for(int i=0;i<len;i++)
    {
        int start=i;
        min=start;
        while(start<len)
        {
            if (x[start]<x[min])
                min=start;
            start++;
        }
        char c=x[i];
        x[i]=x[min];
        x[min]=c;
    }
}
collection init(collection c)
{
    c=(collection)malloc(sizeof(struct Collection));
    c->next=NULL;
    return c;
}
int createmember(char *x,char *y)
{
    char *c=x;
    int num=0;
    while(*c)
    {
        if ((*c>='a'&&*c<='z')||(*c>='A'&&*c<='Z')||(*c>='0'&&*c<='9'))
        {
            *y=*c;
            y++;
            num++;
        }
        c++;
    }
    return num;
}
collection createinit(collection c,char z[MAXSIZE],int n)
{
    collection p=c;
    for(int i=0;i<n;i++)
    {
        collection q=(collection)malloc(sizeof(struct Collection));
        q->c=z[i];
        p->next=q;
        p=q;
    }
    p->next=NULL;
    return c;
}
collection bing(collection b,char x[MAXSIZE],char y[MAXSIZE])
{
    int flag=0;
    createinit(b,x,n1);
    collection p1=b->next;
    for(int i=0;i<n2;i++)
    {
        while(p1!=NULL)
        {
            if (y[i]==p1->c)
            {
                flag=1;
                break;
            }
            p1=p1->next;
        }
        p1=b->next;
        if (flag==0)
        {
            collection q=(collection)malloc(sizeof(struct Collection));
            q->c=y[i];
            if (p1==NULL)
            {
                b->next=q;
                q->next=NULL;
            }
            else
            {
                while (p1!=NULL)
                {
                    if (q->c<p1->c)
                    {
                        q->next=p1;
                        b->next=q;
                        break;
                    }
                    else if (q->c>=p1->c)
                    {
                        if (p1->next!=NULL&&q->c<p1->next->c)
                        {
                            q->next=p1->next;
                            p1->next=q;
                            break;
                        }
                        else if (q->c>=p1->c&&p1->next==NULL)
                        {
                            p1->next=q;
                            p1=q;
                            p1->next=NULL;
                        }
                    }
                    p1=p1->next;
                }
            }
        }
        flag=0;
    }
    return b;
}
collection jiao(collection j,char x[MAXSIZE],char y[MAXSIZE])
{
    collection j1=init(j1),j2=init(j2);
    createinit(j1,x,n1);
    createinit(j2,y,n2);
    collection p=j,p1=j1->next,p2=j2->next;
    while (p1!=NULL)
    {
        while(p2!=NULL)
        {
            if (p1->c==p2->c)
            {
                collection q=(collection)malloc(sizeof(struct Collection));
                q->c=p1->c;
                p->next=q;
                p=q;
            }
            p2=p2->next;
        }
        p1=p1->next;
        p2=j2->next;
    }
    p->next=NULL;
    clear(j1);
    clear(j2);
    return j;
}
collection cha(collection c,char x[MAXSIZE],char y[MAXSIZE])
{
    int flag=0;
    collection c1=init(c1),c2=init(c2);
    createinit(c1,x,n1);
    createinit(c2,y,n2);
    collection p=c,p1=c1->next,p2=c2->next;
    while (p1!=NULL)
    {
        while(p2!=NULL)
        {
            if (p1->c==p2->c)
            {
                flag=1;
                break;
            }
            p2=p2->next;
        }
        if (flag==0)
        {
            collection q=(collection)malloc(sizeof(struct Collection));
            q->c=p1->c;
            p->next=q;
            p=q;
        }
        p1=p1->next;
        p2=c2->next;
        flag=0;
    }
    p->next=NULL;
    clear(c1);
    clear(c2);
    return c;
}
collection huan(collection h,collection j,char x[MAXSIZE],char y[MAXSIZE])
{
    collection h1=init(h1),h2=j->next,p,q,r;
    h1=bing(h1,x,y);
    p=h1;
    q=h1->next;
    while(h2!=NULL)
    {
        while(q!=NULL)
        {
            if (h2->c==q->c)
            {
                r=q;
                q=q->next;
                p->next=q;
                free(r);
                break;
            }
            else
            {
                q=q->next;
                p=p->next;
            }
        }
        h2=h2->next;
    }
    h=h1;
    return h;
}
void output(collection C)
{
    collection head=C->next;
    printf("{");
    while(head!=NULL)
    {
        if (head->next==NULL)
            printf("%c",head->c);
        else
            printf("%c,",head->c);
        head=head->next;
    }
    printf("}");
}
int main()
{
    char a[MAXSIZE],b[MAXSIZE],a1[MAXSIZE],b1[MAXSIZE];
    collection B=init(B),J=init(J),C=init(C),H=init(H);
    scanf("%s",a);
    scanf("%s",b);
    n1=createmember(a,a1);
    n2=createmember(b,b1);
    sort(a1,n1);
    sort(b1,n2);
    B=bing(B,a1,b1);
    J=jiao(J,a1,b1);
    C=cha(C,a1,b1);
    H=huan(H,J,a1,b1);
    output(B);
    printf("\n");
    output(J);
    printf("\n");
    output(C);
    printf("\n");
    output(H);
    clear(B);
    clear(J);
    clear(C);
    clear(H);
    return 0;
}

结语：

        本人小萌新，有不对的还请大佬指出，谢谢！！！

玄空wxy
关注
  • 19
    点赞
  • 踩
  • 70
    收藏
    觉得还不错? 一键收藏
  • 8
    评论
c语言集合运算有菜单,怎样用C语言实现集合运算
weixin_42321086的博客
05-18 1299
【转】STL算法-合并(集合)hechao322514692017-02-24R：集合运算thoixy29792014-10-27C++ STL 集合运算weixin_429930546052018-08-24集合的整数表示u0115831201092017-10-02集合运算weixin_42868863292019-01-22c语言集合的运算qq_2673824952015-05-22Tsin...
离散数学之集合论(上)
Cukor丘克的博客
11-06 1108
离散数学之集合论 文章目录离散数学之集合论使用的书籍写作的目的集合概念集合的基本性质集合的表示枚举法叙述法归纳法递归指定集合法文氏图解法集合和元素的关系集合与集合的关系几个特殊的集合 使用的书籍 《离散数学及其应用》（第3版）傅彦等编著。 写作的目的 为了记录学习离散数学的过程。写下自己理解的离散数学，就是为了边学习边记录就比较有意思。个人水平有限，文章中有错误的地方，大家可以指出来。然后我主要写的也是我理解的，课本上的带一下就行，如果把课本上的也写下来，那你还不如直接看课本。 集合 英文单词是se
java:集合运算
Claire的博客
03-01 968
java:集合运算 题目 问题描述 　　给出两个整数集合A、B，求出他们的交集、并集以及B在A中的余集。 输入格式 　　第一行为一个整数n，表示集合A中的元素个数。 　　第二行有n个互不相同的用空格隔开的整数，表示集合A中的元素。 　　第三行为一个整数m，表示集合B中的元素个数。 　　第四行有m个互不相同的用空格隔开的整数，表示集合B中的元素。 　　集合中的所有元素均为int范围内的整数，n、m&...
离散数学-集合的简单运算【并、交、差、补、环合（对称差）】
热门推荐
Snikai1的博客
08-14 1万+
关于集合的并交差 1.集合的常用运算： 并集：X∪Y={x | x∈X或x∈Y}。 交集：X∩Y={x | x∈X且x∈Y}。 差集：X-Y={x | x∈X且x∉Y}。 如果X∩Y=∅，那么集合X与Y不相交。如果集合X和Y是集族S中的不同集合且X和Y不相交，那么集族S两两不相交。 #include <stdio.h> #define N 100 main() { int a[N],b[N],c[N],d[N],e[N],h[N]; int aa[N],bb[.
Python编程习题（60）：Python-求集合A和B的交集、并集和补集
qq_68937706的博客
06-02 2145
输入两个集合A和B，输出它们的交集、并集和补集。
离散数学：笛卡尔乘积（c语言链表实现）
m0_53621849的博客
11-25 3082
给定两个集合A和B，输出A和B的笛卡尔乘积。
数据结构实验1 集合的交、并、差
Far_Rainbow的博客
10-25 1959
姓名：Far_Rainbow 学号： 202505000X 专业： 软件工程 年级：2020级 实验名称：实验1 集合的交、并、差 实验内容： （1）实验目的 通过该实验，让学生复习巩固C语言中的循环结构、循环控制条件、分支结构和数组/链表、函数的调用等有关内容，体会到用数组存储集合时，需要记录集合元素的个数，否则输出结果会出现数据越界现象。 （2）实验内容 通过键盘，分别输入两个数据元素类型为正整数的集合A和B，以负数输入为结束条件，输出两个集合的交、并、差。 （3）实验要求 从程序完善性上考虑，集合元
【数据结构综合课设】实现集合的交、并、补、差等操作（大量数据）
Liuda066的博客
05-25 3914
【C语言-数据结构】实现大规模数据（随机数）集合创建、显示，元素查找、插入、排序、删除以及集合的交、并、差、补，求势，求top-k问题。
【C语言】数据结构：数组，链表，栈，队列，树
airyv的博客
12-19 2655
3 线性结构 3.1 【数组】连续存储 1、什么叫做数组 元素类型相同，大小相等（数组传参，只要传进去首地址和长度就行） 2、数组的优缺点（相对于链表）： 优点： 存取速度快 缺点： 事先必须知道数组的长度 插入删除元素很慢 空间通常是有限制的 需要大块连续的内存块 插入删除元素的效率很低 定义一个数组至少需要3个参数：首地址，长度，有效个数。 用指针自己定义一个数组： # include <stdio.h> # include <malloc.h>
离散数学实验4：欧拉图的判定并输出所有欧拉（回）路
11-25
离散数学是计算机科学中的基础学科，它研究的是离散而非连续的对象，如集合、图、逻辑等。在本实验“离散数学实验4：欧拉图的判定并输出所有欧拉（回）路”中，我们将聚焦于图论的一个重要概念——欧拉路径和欧拉...
C 实现离散数学中求集合.rar
08-30
下面我们将详细探讨如何用C语言来实现离散数学中的集合操作。 首先，我们需要定义一个数据结构来表示集合。一种常见的方法是使用数组或链表，但鉴于C语言的动态内存分配特性，我们通常会选择动态数组（例如，使用...
c语言实现集合并交差
05-24
本话题将详细介绍如何用C语言利用单链表数据结构来实现集合的合并、交集和差集。 首先，我们需要创建一个表示链表节点的结构体，它通常包含两个部分：元素值和指向下一个节点的指针。在C语言中，这可以定义为： ``...
c语言实现离散的真值表判断、并交差集、判断二元关系、判断欧拉图
05-22
2. **并交差集**：集合的并、交、差运算在离散数学中是非常基本的操作。在C语言中，这些操作可以通过数组或链表实现。并集操作可以将两个集合的所有元素合并到一个集合中，交集操作找出两个集合共有的元素，而差集则...
离散上级作业 C语言
03-17
离散上级作业主要涉及到计算机科学中的离散数学和C语言编程技术。离散数学是计算机科学的基础课程之一，它研究不连续的、个体的、可数的数学对象，包括集合论、图论、逻辑和组合数学等内容。在这个作业中，我们将...
IO多路复用-select的使用详解【C语言】
qq_42037383的博客
07-21 890
IO多路转接也称为IO多路复用，它是一种网络通信的手段（机制），通过这种方式可以同时监测多个文件描述符并且这个过程是阻塞的，一旦检测到有文件描述符就绪（ 可以读数据或者可以写数据）程序的阻塞就会被解除，之后就可以基于这些（一个或多个）就绪的文件描述符进行通信了。通过这种方式在单线程/进程的场景下也可以在服务器端实现并发。常见的IO多路转接方式有：select、poll、epoll。
C语言——字符串中sizeof和strlen的辨析
weixin_45720999的博客
07-19 388
在C语言中，sizeof 和 strlen 函数在处理字符串时有明显不同的作用和结果。使用不当很容易出现错误......
【C语言】 约瑟夫环，循环链表实现
最新发布
2301_77133426的博客
07-22 82
1、循环链表实现约瑟夫环，每次经过特定步数删除一个元素
c语言（7.22）
fhgfyrsg的博客
07-22 368
在7，23，79，81，103，127，131，147中查找数据*/核心思路：就是从数组的0索引开始，依次往后查找，如果找到了，就会返回数据对应的索引。如果没有找到，就会返回-1。//不是用mid和num进行比较。//2.定义变量表示要查找的数据。//2，定义一个要查的数据。/*需求：数组的二分查找。//mid应该放在循环里面。/* 需求：数组的基本查找。
数据结构C语言版：循环链表操作与抽象数据类型
此外，离散数学作为基础，为理解数据结构提供了必要的数学背景。 在实际应用中，数据结构可以用于各种系统，如书目检索系统、教师资料档案管理和交通灯管理等。这些系统通常涉及数据对象的存储和操作，可能使用到...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值