1、给定含有n个元素集合U的两个子集A和B，求出~A, A∪B,A∩B, A⊕B和A-B，给定来自同一全集的两个多重集合A和B，试求A∪B,A∩B, A-B和A+B

最新推荐文章于 2022-08-08 01:14:57 发布
最新推荐文章于 2022-08-08 01:14:57 发布
阅读量1k 收藏 12
点赞数 4
文章标签： 算法 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51902218/article/details/116863154
版权

注意：两个功能都可实现合并为一个代码，但是并集函数略有定义错误，当出现多重集合时，应当表示为A+B而不是并集形式

1、给定含有n个元素集合U的两个子集A和B，求出~A, A∪B,A∩B, A⊕B和A-B

(1)首先明确并集、交集、差集、对称差、补集写成自定义函数

(2)其次，考虑主函数，在主函数中输入全集U，子集A和B，自定义函数的功能可以通过switch语句让用户自己选择决定

#include <stdio.h>
#include <stdlib.h>
#define N 50

//思路，知道集合A和集合B，利用一个空数组C把A中的集合复制到C中，然后比较A和B，
//当且仅当两者不相等时，存入B中与A不相等的元素
void bingji(int A[],int B[],int la,int lb)
{
    int C[N]={0};
    int i,j,m,k;
    printf("集合A为：\n");
    for(i=0;i<la;i++)
    {
        printf("%d   ",A[i]);
    }
    printf("\n集合B为：\n");
    for(j=0;j<lb;j++)
    {
        printf("%d   ",B[j]);
    }
    for(m=0;m<la;m++)
    {
        C[m]=A[m];
    }
    for(i=0;i<lb;i++)
    {
        int flag=0;
        for(j=0;j<la;j++)
        {
            if(B[i]==A[j])
            {
                flag=1;
            }
        }
        if(flag==0)
        {
            C[m]=B[i];
            m++;
        }
    }
    printf("\n并集为：\n");
    for(k=0;k<(la+lb);k++)
    {
        if(C[k]==0)
        {
            break;
        }
        printf("%d   ",C[k]);
    }
}

void jiaoji(int A[],int B[],int la,int lb)
{
    int C[N]={0};
    int i,j,m,k;
    m=0;
    printf("集合A为：\n");
    for(i=0;i<la;i++)
    {
        printf("%d   ",A[i]);
    }
    printf("\n集合B为：\n");
    for(j=0;j<lb;j++)
    {
        printf("%d   ",B[j]);
    }
    for(i=0;i<lb;i++)
    {
        int flag=1;
        for(j=0;j<la;j++)
        {
            if(B[i]==A[j])
            {
                flag=0;
            }
        }
        if(flag==0)
        {
            C[m]=B[i];
            m++;
        }
    }
    printf("\n交集为：\n");
    for(k=0;k<m;k++)
    {
        if(C[k]==0)
        {
            break;
        }
        printf("%d   ",C[k]);
    }
}


void chaji(int A[],int B[],int la,int lb)
{
    int C[N]={0};
    int i,j,m,k;
    m=0;
    printf("集合A为：\n");
    for(i=0;i<la;i++)
    {
        printf("%d   ",A[i]);
    }
    printf("\n集合B为：\n");
    for(j=0;j<lb;j++)
    {
        printf("%d   ",B[j]);
    }
    for(i=0;i<la;i++)
    {
        int flag=1;
        for(j=0;j<lb;j++)
        {
            if(B[i]==A[j])
            {
                flag=0;
            }
        }
        if(flag==1)
        {
            C[m]=A[i];
            m++;
        }
    }
    printf("\n差集为(A-B)：\n");
    for(k=0;k<m;k++)
    {
        if(C[k]==0)
        {
            break;
        }
        printf("%d   ",C[k]);
    }
}

void duichencha(int A[],int B[],int la,int lb)
{
    int C[N]={0};
    int D[N]={0};
    int i,j,m,n,k;
    m=0;
    n=0;
    printf("集合A为：\n");
    for(i=0;i<la;i++)
    {
        printf("%d   ",A[i]);
    }
    printf("\n集合B为：\n");
    for(j=0;j<lb;j++)
    {
        printf("%d   ",B[j]);
    }
    for(i=0;i<lb;i++)
    {
        int flag=1;
        for(j=0;j<la;j++)
        {
            if(B[i]==A[j])
            {
                flag=0;
            }
        }
        if(flag==1)
        {
            C[m]=B[i];
            m++;
        }
    }
    for(i=0;i<la;i++)
    {
        int flag=1;
        for(j=0;j<lb;j++)
        {
            if(A[i]==B[j])
            {
                flag=0;
            }
        }
        if(flag==1)
        {
            D[n]=A[i];
            n++;
        }
    }
    printf("\n对称差集为：\n");
    for(k=0;k<m;k++)
    {
        if(C[k]==0)
        {
            break;
        }
        printf("%d   ",C[k]);
    }
    for(k=0;k<n;k++)
    {
        if(D[k]==0)
        {
            break;
        }
        printf("%d   ",D[k]);
    }
}

void buji(int A[],int U[],int la)
{
    int C[N]={0};
    int i,j,m,k;
    m=0;
    printf("集合A为：\n");
    for(i=0;i<la;i++)
    {
        printf("%d   ",A[i]);
    }
    for(i=0;i<20;i++)
    {
        int flag=1;
        for(j=0;j<la;j++)
        {
            if(U[i]==A[j])
            {
                flag=0;
            }
        }
        if(flag==1)
        {
            C[m]=U[i];
            m++;
        }
    }
    printf("\n补集为~A：\n");
    for(k=0;k<m;k++)
    {
        if(C[k]==0)
        {
            break;
        }
        printf("%d   ",C[k]);
    }
}
int main()
{
    int n1,n2,k;
    n1=0;
    n2=0;
    k=0;
    int A[N],B[N];
    int U[N]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20};
    printf("全集U为:");
    for(k=0;k<N;k++)
    {
        if(U[k]==0)
        {
            break;
        }
        printf("%d   ",U[k]);
    }
    printf("\n请输入第一个集合\n注意：输入0即为结束输入\n");
    while(1)
    {
        scanf("%d",&A[n1]);
        if(A[n1]==0)
            break;
        //printf("第一个集合为：%d\n",A[n1]);
        n1++;
    }
    printf("请输入第二个集合\n注意：输入0即为结束输入\n");
    while(1)
    {
        scanf("%d",&B[n2]);
        if(B[n2]==0)
            break;
        //printf("第二个集合为：%d\n",B[n2]);
        n2++;
    }
    int key=0;
    printf("请输入要进行的操作\n1为并集\n2为交集\n3为差集\n4为对称差\n5为补集\n");
    scanf("%d",&key);
    switch(key)
    {
    case 1:
        bingji(A,B,n1,n2);
        break;
    case 2:
        jiaoji(A,B,n1,n2);
        break;
    case 3:
        chaji(A,B,n1,n2);
        break;
    case 4:
        duichencha(A,B,n1,n2);
        break;
    case 5:
        buji(A,U,n1);
        break;

    }

}

(3)主函数

思路：给出全集，让用户自己输入子集A和B，并且通过循环到最后一个数为0停止知道子集A和B的长度，调用switch语句让用户自己选择需要计算的操作

int main()
{
    int n1,n2,k;
    n1=0;
    n2=0;
    k=0;
    int A[N],B[N];
    int U[N]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20};
    printf("全集U为:");
    for(k=0;k<N;k++)
    {
        if(U[k]==0)
        {
            break;
        }
        printf("%d   ",U[k]);
    }
    printf("\n请输入第一个集合\n注意：输入0即为结束输入\n");
    while(1)
    {
        scanf("%d",&A[n1]);
        if(A[n1]==0)
            break;
        //printf("第一个集合为：%d\n",A[n1]);
        n1++;
    }
    printf("请输入第二个集合\n注意：输入0即为结束输入\n");
    while(1)
    {
        scanf("%d",&B[n2]);
        if(B[n2]==0)
            break;
        //printf("第二个集合为：%d\n",B[n2]);
        n2++;
    }
    int key=0;
    printf("请输入要进行的操作\n1为并集\n2为交集\n3为差集\n4为对称差\n5为补集\n");
    scanf("%d",&key);
    switch(key)
    {
    case 1:
        bingji(A,B,n1,n2);
        break;
    case 2:
        jiaoji(A,B,n1,n2);
        break;
    case 3:
        chaji(A,B,n1,n2);
        break;
    case 4:
        duichencha(A,B,n1,n2);
        break;
    case 5:
        buji(A,U,n1);
        break;

    }

}

(4)并集

思路：首先显示集合A和集合B，其次先让集合A中的所有元素存入空数组C中，然后循环比较A和B有哪一个不同的元素，不同的元素就存入C中，最后输出C

void bingji(int A[],int B[],int la,int lb)
{
    int C[N]={0};
    int i,j,m,k;
    printf("集合A为：\n");
    for(i=0;i<la;i++)
    {
        printf("%d   ",A[i]);
    }
    printf("\n集合B为：\n");
    for(j=0;j<lb;j++)
    {
        printf("%d   ",B[j]);
    }
    for(m=0;m<la;m++)
    {
        C[m]=A[m];
    }
    for(i=0;i<lb;i++)
    {
        int flag=0;
        for(j=0;j<la;j++)
        {
            if(B[i]==A[j])
            {
                flag=1;
            }
        }
        if(flag==0)
        {
            C[m]=B[i];
            m++;
        }
    }
    printf("\n并集为：\n");
    for(k=0;k<(la+lb);k++)
    {
        if(C[k]==0)
        {
            break;
        }
        printf("%d   ",C[k]);
    }
}

(5)交集

思路：显示出集合A和B，当A和B都相等共有时，存入C中，然后输出

void jiaoji(int A[],int B[],int la,int lb)
{
    int C[N]={0};
    int i,j,m,k;
    m=0;
    printf("集合A为：\n");
    for(i=0;i<la;i++)
    {
        printf("%d   ",A[i]);
    }
    printf("\n集合B为：\n");
    for(j=0;j<lb;j++)
    {
        printf("%d   ",B[j]);
    }
    for(i=0;i<lb;i++)
    {
        int flag=1;
        for(j=0;j<la;j++)
        {
            if(B[i]==A[j])
            {
                flag=0;
            }
        }
        if(flag==0)
        {
            C[m]=B[i];
            m++;
        }
    }
    printf("\n交集为：\n");
    for(k=0;k<m;k++)
    {
        if(C[k]==0)
        {
            break;
        }
        printf("%d   ",C[k]);
    }
}

(6)差集

思路：从A开始循环比较，A和B不相等时，存入C中，得到A-B，如果要得到B-A，就从B开始循环比较

void chaji(int A[],int B[],int la,int lb)
{
    int C[N]={0};
    int i,j,m,k;
    m=0;
    printf("集合A为：\n");
    for(i=0;i<la;i++)
    {
        printf("%d   ",A[i]);
    }
    printf("\n集合B为：\n");
    for(j=0;j<lb;j++)
    {
        printf("%d   ",B[j]);
    }
    for(i=0;i<la;i++)
    {
        int flag=1;
        for(j=0;j<lb;j++)
        {
            if(B[i]==A[j])
            {
                flag=0;
            }
        }
        if(flag==1)
        {
            C[m]=A[i];
            m++;
        }
    }
    printf("\n差集为(A-B)：\n");
    for(k=0;k<m;k++)
    {
        if(C[k]==0)
        {
            break;
        }
        printf("%d   ",C[k]);
    }
}

(7)对称差

思路：在A中，不在B中同时在B中，不在A中，所以用两个差集的思路即可

void duichencha(int A[],int B[],int la,int lb)
{
    int C[N]={0};
    int D[N]={0};
    int i,j,m,n,k;
    m=0;
    n=0;
    printf("集合A为：\n");
    for(i=0;i<la;i++)
    {
        printf("%d   ",A[i]);
    }
    printf("\n集合B为：\n");
    for(j=0;j<lb;j++)
    {
        printf("%d   ",B[j]);
    }
    for(i=0;i<lb;i++)
    {
        int flag=1;
        for(j=0;j<la;j++)
        {
            if(B[i]==A[j])
            {
                flag=0;
            }
        }
        if(flag==1)
        {
            C[m]=B[i];
            m++;
        }
    }
    for(i=0;i<la;i++)
    {
        int flag=1;
        for(j=0;j<lb;j++)
        {
            if(A[i]==B[j])
            {
                flag=0;
            }
        }
        if(flag==1)
        {
            D[n]=A[i];
            n++;
        }
    }
    printf("\n对称差集为：\n");
    for(k=0;k<m;k++)
    {
        if(C[k]==0)
        {
            break;
        }
        printf("%d   ",C[k]);
    }
    for(k=0;k<n;k++)
    {
        if(D[k]==0)
        {
            break;
        }
        printf("%d   ",D[k]);
    }
}

(8)补集

思路：在全集U中做循环比较A中只要没有，就存入C中，然后输出即可得出~A，~B思路也是如此

void buji(int A[],int U[],int la)
{
    int C[N]={0};
    int i,j,m,k;
    m=0;
    printf("集合A为：\n");
    for(i=0;i<la;i++)
    {
        printf("%d   ",A[i]);
    }
    for(i=0;i<20;i++)
    {
        int flag=1;
        for(j=0;j<la;j++)
        {
            if(U[i]==A[j])
            {
                flag=0;
            }
        }
        if(flag==1)
        {
            C[m]=U[i];
            m++;
        }
    }
    printf("\n补集为~A：\n");
    for(k=0;k<m;k++)
    {
        if(C[k]==0)
        {
            break;
        }
        printf("%d   ",C[k]);
    }
}

算法参考

CSDN博主Kilig*
 

花墩墩
关注
通过键盘，分别输入两个数据元素类型为正整数的集合A和B，以负数输入为结束条件，输出两个集合的交、并、差。
qq_46786580的博客
10-14 2415
通过键盘，分别输入两个数据元素类型为正整数的集合A和B，以负数输入为结束条件，输出两个集合的交、并、差。------------------------------------------- 使用菜单形式对应各个操作，应允许用户反复查看结果，想结束程序时，输入负数结束，使其编成一个完整的小软件。 菜单参考示例如下： 1—输入集合A和B 2—求集合A交B 3—求集合A并B 4—求集合A-B 退出，输入一个负数！ 3.验收/测试用例 输入： A={1,2,3,4,5} B={3,4,5,6,7
离散数学 8.1.2子集（C语言）
extern_int_Lin的博客
02-25 2634
[问题描述] 给定一个集合A，求A的所有非空子集。例如A={a,b}时，则它的所有非空子集为{a},{b},{a,b}。集合A不空，并且A的元素个数不超过10个。 [输入] 有多组测试数据，每组测试数据为一行。 每行表示一个集合，集合由一对大括号括起来，集合之间的元素用一个逗号隔开。之间没有任何的空白字符。已经知道集合元素按字典顺序排列。 [输出] 每组测试数据输出为2^n-1...
C语言---给出含有n个元素的集合的两个子集A和B，利用位串求出：Ã，A∩B，A∪B，A－B，A⊕B
qq_63101755的博客
07-04 373
C语言---给出含有n个元素的集合的两个子集A和B，利用位串求出：Ã，A∩B，A∪B，A－B，A⊕B
数据结构中链表实现A∩B，A∪B
m0_63605756的博客
10-30 843
#include <iostream> using namespace std; #include <stdio.h> #include <stdlib.h> typedef struct LNode{ int data; struct LNode *next; }LNode,*LinkList; int Search(LinkList L,int e); void jiaoji(LinkList Q,LinkList E); int main() { ...
SQL编程-组队学习打卡task04-集合运算
sadbird1729的博客
07-20 342
集合运算
全国通用版2018_2019高中数学第一章集合检测A新人教B版必修1
08-06
7. 定义新运算：A*B运算定义为A*B={z|z=xy(x+y),x∈A,y∈B}，这需要对给定的集合A和B的元素进行运算组合，求出所有可能的z值，然后求和，如A*B的所有元素之和为18。 8. 数轴表示法：在处理集合与不等式关系时，数轴...
(a, b, k)-临界图的一个充分条件 (2010年)
05-06
- **引理1**：给出了(a, b, k)-临界图的另一个判断条件，即对任意顶点子集S，删除S后剩下的图G-S的特定度数之和小于等于b|S|的k倍。 - **引理2**：讨论了图的一个特殊划分，并说明了在给定条件下存在图的一个独立集...
PTA 子集和问题(回溯法):给定集合S，S中有n个正整数，M是一个正整数。...
qwqc262的博客
12-17 3341
问题 给定集合S，S中有n个正整数，M是一个正整数。子集和问题判定是否存在S的一个子集S1，使得S1中各元素之和等于M。请设计回溯法求解子集和问题，如果问题无解，输出“No Solution”,问题有解，则输出满足子集S1中各元素的值。 输入样例 4 31 13 24 11 7 输出样例 13 24 11 7 24 7 详解请看代码注释 源代码 #include<iostream> using namespace std; int* arr,*result;
编写一个程序，对输入的任意正整数n，打印出集合{0，1，…，n-1}的所有子集。
iDJ77的博客
08-08 2481
编写一个程序，对输入的任意正整数n，打印出集合{0，1，…，n-1}的所有子集。
回溯法求给定集合的子集和
qq_45439980的博客
06-15 762
对于给定的正整数集合S={w_1，w_2，……，w_n}和正整数C, 编写程序计算S的一个子集S1，使得S1的和为C。 输入要求：输入的第1行为两个整数C和N，分别表示子集S1的和和元素的个数。第2行有N个整数，表示该集合中的每一个元素，1≤N≤10000。 输出要求：当问题有解时输出构成该子集的每个元素；当问题无解是输出“No Solution!”。 样例输入： 5 3 2 2 6 5 4 样例输出： No Solution! 如果只需要求出一个满足和为C的子集 #include<stdio.h&g
离散数学：求集合的并、交、差、环和（c语言链表实现）
m0_53621849的博客
11-25 4978
给定两个集合A，B，求其并、交、差、环和 输入分为两行，第一行输入集合A,第二行输入集合B, 其中各包括若干个元素,每个元素用“，”隔开，用“{}”表示空集。元素按照字典序排列。 输出格式： 输出分为4行，第一行输出A∪B的集合，第二行输出A∩B的集合，第三行输出A-B的集合，第四行输出A⊕B的集合。元素按照字典序排列。 输入样例： {a,b,c,d} {c,d,...
集合覆盖问题
Valieli的博客
02-16 4431
【集合覆盖问题】 集合覆盖问题可以描述为： 给定 n 个元素的集合U,U 的子集S1,…,SmS_1,…,S_mS1​,…,Sm​ 以及数 k, 问在这些子集中有一组子集，它的并等于整个 U 且至多含有 k 个子集？ 如图3为一个集合覆盖问题的实例。 图3 集合覆盖问题实例 在图3中，有3个子集（即数k为3）{S3,S4,S5S_3,S_4,S_5S3​,S4​,S5​},它的并等于整个 U。 ...
集合：求A、B两个集合的交集、并集和补集的代码（C语言）
Keep Learning
10-21 5万+
集合：求A、B两个集合的交集、并集和补集的代码（C语言）     #include #define N 100 main(){ int a[N],b[N],c[N],d[N]; int aa[N],bb[N]; int i,j,k=1; int x=1,y=1,z; int m,n; int flag; printf("please input Number of A:\n"
N个元素集合的M子集问题
yiduyangyi的专栏
07-14 2063
一、问题描述 一根有n个元素的集合，求该集合所有m个元素的子集 二、解法 1、递归模式 每个元素要么在子集，要么不在。 /*** nums 集合* m 子集大小* idx 标记集合的第idx号元素是否进行了选择* rst 结果集* item 临时集*/private void select(int[] nums, int m, int idx, Set> rst, List it
算法导论之P、NP、NPC问题
bcb5202的博客
04-20 9569
P、NP、NPC概念 > P问题：能够在多项式时间内解决的决策问题。 —举例: 图搜索问题、最短路径问题、最小生成树问题······ > NP问题：不能在多项式时间内解决或不确定能不能在多项式时间内解决，但能在多项式时间验证的问题。 —验证：给定一个问题的实例、证书（类似于证据），需要验证这个证书是这个问题的正确答案。 — 举例：汉密尔顿路径，实例为G=(V,E)
离散数学（4）——集合的概念和集合之间的关系、集合的运算、基本的集合恒等式
Allure_07的博客
03-18 1万+
一、集合的表示 列举法：列出集合中的全体元素，元素之间用逗号分开，然后用花括号括起来 描述法：用谓词P(x)表示x具有性质P，用{x|P(x)}表示具有性质P的集合 注意事项：集合中的元素是各不相同的 ​ 集合中的元素不规定顺序 ​ 集合的两种表示法可以互相转化 常用的数集合：自然数集合N；整数集合Z；有理数集合Q；实数集合R；复数集合C 二、集合之间的...
微软公司等数据结构+算法面试100题(第1-100题)全部出炉
热门推荐
结构之法 算法之道
12-06 23万+
微软等公司数据结构+算法面试100题(第1-100题)首次完整亮相                        作者:July、2010年12月6日。更新：现今，这100题的答案已经全部整理出来了，微软面试100题2010年版全部答案集锦：http://blog.csdn.net/v_july_v/article/details/6870251。关于此100道面试题的所有一切详情，包括答案，资源
给定一个集合，求出此集合所有子集元素之和。c++
最新发布
05-01
可以使用递归来解决这个问题。对于一个集合，它的所有子集可以分为两类：包含集合中的最后一个元素和不包含集合中的最后一个元素。因此，我们可以递归地计算这两种情况的和，然后将它们相加即可。 下面是一个示例的 C 代码： ```c #include <stdio.h> int subset_sum(int set[], int n) { if (n == 0) { return 0; } else { int last = set[n-1]; int sum_without_last = subset_sum(set, n-1); int sum_with_last = sum_without_last + last; return sum_without_last + sum_with_last; } } int main() { int set[] = {1, 2, 3}; int n = sizeof(set) / sizeof(set[0]); int total_sum = subset_sum(set, n); printf("The sum of all subsets is %d\n", total_sum); return 0; } ``` 输出结果为： ``` The sum of all subsets is 14 ``` 其中，`subset_sum` 函数计算给定集合的所有子集元素之和，`main` 函数则是一个示例，用于测试 `subset_sum` 函数。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值