精华内容
下载资源
问答
  • 功能:能演示执行集合的并交差运算 通过有序链表来实现此次运算
  • 集合的并差运算C语言

    千次阅读 多人点赞 2020-11-30 21:44:15
    编制一个能演示执行集合的并差运算的程序。 二、问题分析和任务定义 1. 需求分析(完成的任务、提供的功能) (1)集合的元素限定为小写字母字符 [‘a’…’z’] 。 (2)集合的元素判定和子集判定运算。 (3)求...

    这是我的课程设计,写了蛮久的了,当时搜好多都搜不到,既然已经完成了,就拿出来和大家一起分享讨论,这也是我的第一篇原创文章。(自己水平太有限了,无法跟这里的大佬们相比,但是可以一起交流学习嘛~ 有错误请多指出哦~)
    如果觉得有帮助一定要点赞哦~ ~ ~ ~ ~

    • 文章后面有代码哦~~

    一、课题的背景与意义

    编制一个能演示执行集合的并、交和差运算的程序。

    二、问题分析和任务定义

    1. 需求分析(完成的任务、提供的功能)

    (1)集合的元素限定为小写字母字符 [‘a’…’z’] 。
    (2)集合的元素判定和子集判定运算。
    (3)求集合的补集。
    (4)集合的混合运算表达式求值。
    (5)集合的元素类型推广到其他类型,甚至任意类型

    2. 重点和难点

    (1)如何将元素只限定于小写字母,不包括其它元素
    (2)输入的集合中含有空集,该如何判断
    (3)混合运算表达式的计算,当表达式中含有取反符号“~”时,该怎么处理
    (4)表达式中含有圆括号时该怎么处理
    (5)如何判断表达式的输入不符合规范,当不符合规范的时候该如何让其运行

    3. 测试数据

    (1)Set1=“magazine”,Set2=“paper”,
    Set1∪Set2=“aegimnprz”,Setl ∩Set2=“ae”,Set1-Set2=“gimnz”。
    (2) Set1= " 012oper4a6tion89",Set2=“error data”,
    Set1∪Set2=“adeinoprt”,Setl ∩Set2=“aeort”,Set1-Set2=“inp”。

    三、概要设计

    1. 系统的设计与分析(系统流程图)

    开始程序时,进行集合元素类型选择,当输入数字“1”时将进行小写字母集合运算,当输入数字“2”时将进行任意可显示元素的运算。选择结束之后,根据提示,输入两个集合,按下回车后即可进行相应的集合运算操作。当选择元素查找选项时,根据提示输入要寻找的元素,结构显示AB集合中是否含有。当选择混合运算选项时,按照表达式规则正确输入集合表达式,按下回车后,显示结果。
    图1 系统流程图

    2.数据结构的选择

    本实验使用的是链表结构。由于无法确定输入集合的长度,因此采用动态链表进行储存比较方便,由于运算中经常出现添加、删除的操作,使用链表将会将时间复杂度降低,不需要像顺序表影响其他元素的位置。链表的时间复杂度依据操作进行,当不进行排序时时间复杂度为0,空间复杂度也为0。
    排序使用的是简单选择排序,给每一个位置选择当前最小元素,由于集合中不存在重复的元素,因此在输入的时候,就将重复的元素剔除。时间复杂度为O(),空间复杂度则为0。
    在进行混合运算时采用堆栈操作,建立两个堆栈类型,一个存放数据,一个用于存放符号。堆栈是后进先出,符合表达式的运算顺序,即优先级高的后出,优先级低的先进行运算,并将结果存放在数据栈中。

    四、详细设计

    1.数据类型的定义
    1)集合的结构定义
    /*链表集合*/
    typedef struct PNode {
    	char data;
    	struct PNode* next;
    }PNode, * PLink;
    /* 顺序栈结构(符号栈) */
    
    2)顺序表的结构定义,方便之后进行混合运算表达式的求值
    typedef struct
    {
    	SElemType data[MAXSIZE];
    	int top; /* 用于栈顶指针 */
    }SqStack;
    /* 顺序栈结构(集合栈) */
    typedef struct
    {
    	PLink data[MAXSIZE];
    	int top; /* 用于栈顶指针 */
    }PLinkStack;
    
    2.核心算法的设计与实现
    1)集合的并

    对A集合进行调整,将不重复的内容放入集合C中,然后再对B集合进行调整,将补重复的内容放入到C集合中。主要通过while循环进行控制。采用含有头结点的链表以及头插法。如图 2所示
    图2 集合的并

    2)集合的交集

    对集合A和B同时进行遍历,以集合B为模板,将集合A中的一个元素与集合B中的所有元素进行比较,若有相同的元素则插入到集合C中,并在插入之前再判断一下集合C中是否已有该元素,如果已有即不尽兴插入,否则用头插法进行插入。如图 3所示图3 集合的交集

    3)集合的差集

    与集合的交集遍历类似,将集合A和集合B同时进行遍历,当两集合中含有相等的元素则跳出,让集合A的下一个元素一次和集合B进行遍历,只有当集合B全部遍历完了才说明有不同的元素,并最后再在集合C中进行判断,查看是否有重复的元素。如图 4所示。图4集合的差集

    4)集合的补集

    求集合的补集时需要分情况讨论,当限定元素只是小写字母的时候,其全集也就是‘a’~‘z’,但当其全集是任意类型的时候,全集的范围就会更大。而补集的求解则是利用ASCII码来进行判断,当元素不存在时,就调用函数进行元素的添加,也就是链表的增加。如图 5所示
    图5集合的补集

    5)排序

    采用的是简单排序算法,每一次递归都确定一个最小的元素。

    6)混合运算表达式

    在对混合运算的表达式的解析的过程中,需要使用到的是栈的应用。混合表达式的运算中需要对的输入的表达式进行规范性的判断,使用的是if-else语句进行判断。具体规则参照表 1运算式正确性的判断条件

    i i+1
    A B 只能是+、-、*、’\0’、)
    ~ 只能是A、B、(
    + - * 不能是+、-、*、’\0’、)
    ( 只能是A、B、~
    ) 只能是+、-、*、’\0’

    五、实验参考代码(核心代码及注释)

    1)集合的并
    void    and (PLink L1, PLink L2, PLink L3) {
    	if (L3->next != NULL)
    		clearList(L3);
    	PLink p, q, s;
    	//对空集的操作
    	if (!L1 || !L2) {
    		if (!L1) {
    			L3 = L2;
    		}
    		else if (!L2) {
    			L3 = L1;
    		}
    		else {
    			L3 = L1;
    		}
    	}
    	//对1号插入3中
    	p = L1->next;
    	while (p) {
    		q = L3->next;
    		while (q && (q->data != p->data)) {//C3号中不含有与1号相同的元素
    			q = q->next;
    		}
    		if (q == NULL) {
    			s = (PLink)malloc(sizeof(PNode));
    			s->data = p->data;
    			s->next = L3->next;
    			L3->next = s;
    		}
    		p = p->next;
    	}
    	//对2号插入3中
    	p = L2->next;
    	while (p) {
    		q = L3->next;
    		while (q && (q->data != p->data)) {//C3号中不含有与1号相同的元素
    			q = q->next;
    		}
    		if (q == NULL) {// //当q遍历完一次都没有找到的话,即q的最后为空时就可以将1中的一个元素插入3中
    			s = (PLink)malloc(sizeof(PNode));
    			s->data = p->data;
    			s->next = L3->next;
    			L3->next = s;
    		}
    		p = p->next;
    	}
    
    }
    
    2)集合的交集
    void intersection(PLink L1, PLink L2, PLink L3) {
    	if (L3->next != NULL)
    		clearList(L3);
    	PLink p, q, s, t;
    	//1
    	p = L1->next;//遍历1
    	while (p) {
    		q = L2->next;//遍历2
    		while (q) {
    	if (p->data == q->data)
    				
    break;//找到相同的就返回
    			else
    				q = q->next;
    		}
    if (q) {//查找3号中有没有相同元素
    			s = L3->next;
    	while (s) {
    	if (s->data == p->data)
    					break;
    				else
    				s = s->next;}
    			if (s == NULL) {
    				t = (PLink)malloc(sizeof(PNode));
    				t->data = p->data;
    				t->next = L3->next;
    				L3->next = t;
    			}
    		}
    		p = p->next;}
    
    3)集合的差集
    void difference(PLink L1, PLink L2, PLink L3) {
    	if (L3->next != NULL)
    		clearList(L3);
    	PLink p, q, s, t;
    	//1
    	p = L1->next;//遍历1
    	while (p) {
    		q = L2->next;
    		while (q) {
    			if (q->data == p->data)
    				break;
    			else
    				q = q->next;
    		}
    		if (q == NULL) {//说明2号遍历完了,并且有不一样的
    			s = L3->next;
    			while (s) {//3号中也没有的话就插入进去
    				if (s->data == p->data)
    					break;
    				else
    					s = s->next;
    			}
    			if (s == NULL) {
    				t = (PLink)malloc(sizeof(PNode));
    				t->data = p->data;
    				t->next = L3->next;
    				L3->next = t;
    			}
    		}
    		p = p->next;
    	}
    }
    
    
    4)集合的补集
    void Neg(PLink L, PLink L3) {
    	if (L3->next != NULL)
    		clearList(L3);
    	PLink p = L;
    
    	int i = 0;
    	while (i < 26) {
    		if (!checkElem(p, i + 97))
    			addElem(L3, i + 97);
    		i++;
    	}
    }
    //任意类型的补集
    void Negany(PLink L, PLink L3) {
    	if (L3->next != NULL)
    		clearList(L3);
    	PLink p = L;
    
    	int i = 0;
    	while (i < 95) {
    		if (!checkElem(p, i + 32))
    			addElem(L3, i + 32);
    		i++;
    	}}
    
    
    5)混合运算表达式

    这是我认为最麻烦的部分,网上搜都搜不到,对于我这种技术不太行的人来说。。。着实有点难。硬写的,不知道对不对,反正目前都能实现(写得有点乱)

    while (str[i] != '\0')
    	{
    		if (str[i] == '+' || str[i] == '-' || str[i] == '*') {
    			if (StackEmpty(s) == TRUE || GetTop(s) == '(' || PStackEmpty(p) == TRUE) {
    				if (StackEmpty(s) == TRUE || GetTop(s) == '(') {
    					Push(&s, str[i]);
    				}
    				if (PStackEmpty(p) == TRUE || GetTop(s) == '(') {
    					PPush(&p, temp);}}
    			else {
    				temp = choose(temp, PGetTop(p), GetTop(s));
    				PPop(&p);
    				PPush(&p, temp);
    				Pop(&s);
    				Push(&s, str[i]);
    }
    			i++;}
    		else if (str[i] == '(') {
    			Push(&s, str[i]);
    			i++;
    			k = 1;}
    		else if (str[i] == ')') {
    			while (GetTop(s) != '(') {
    				temp = choose(temp, PGetTop(p), GetTop(s));
    				PPop(&p);
    				Pop(&s);
    }
    			Pop(&s);//让"("出栈
    			if (GetTop(s) == '~') {
    				Neg(temp, temp2);
    				temp = temp2;
    				Pop(&s);//让"~"出栈
    }
    			k = 0;
    			//temp[0] = temp[1];
    			i++;}
    		else if (str[i] == '~') {
    			if (str[i + 1] == 'A') {
    				if (IsAny == 0) {
    					Neg(A, temp);
    				}
    				else {
    					Negany(A, temp);
    				}
    				i = i + 2;}
    			else if (str[i + 1] == 'B') {
    				if (IsAny == 0) {
    					Neg(B, temp);}
    				else {
    					Negany(B, temp);}
    				i = i + 2;
    			}//当~(A+B)时
    			else if (str[i + 1] == '(') {
    				Push(&s, str[i]);
    				i++;
    			}
    			else {
    				printf("输入有误!“~”后面要有集合");
    				break;}}
    		//输入是集合的情况
    		else if (str[i] == 'A') {
    			temp = A;
    			i++;
    		}
    		else if (str[i] == 'B') {
    			temp = B;
    			i++;}}
    	while (StackEmpty(s) != TRUE)//符号栈不为空
    	{
    		temp = choose(PGetTop(p), temp, GetTop(s));
    		Pop(&s);
    		PPop(&p);
    	}
    	PClearStack(&p);
    	ClearStack(&s);
    	out(temp);
    
    

    六、测试与分析

    1.测试结果

    限定小写元素的集合
    限定小写元素的集合

    加括号的混合运算
    加括号的混合运算

    任意类型元素的集合
    任意类型元素的集合

    混合运算
    混合运算

    附录

    #include<stdio.h>
    #include<stdlib.h>
    
    #define OK 1
    #define ERROR 0
    #define TRUE 1
    #define FALSE 0
    #define MAXSIZE 30 /* 存储空间初始分配量 */
    int IsAny = 0;
    typedef char SElemType; /* SElemType类型根据实际情况而定 */
    /*链表*/
    typedef struct PNode {
    	char data;
    	struct PNode* next;
    }PNode, * PLink;
    
    //链表的初始化
    int Init(PLink L) {
    	if (!L) {
    		return 0;
    	}
    	L->next = NULL;
    	return 1;
    }
    /*******************************************************************/
    /* 顺序栈结构 */
    typedef struct
    {
    	SElemType data[MAXSIZE];
    	int top; /* 用于栈顶指针 */
    }SqStack;
    /*  构造一个空栈S */
    int InitStack(SqStack* S)
    {
    
    	S->top = -1;
    	return OK;
    }
    /* 把S置为空栈 */
    int ClearStack(SqStack* S)
    {
    	S->top = -1;
    	return OK;
    }
    /* 若栈S为空栈,则返回TRUE,否则返回FALSE */
    int StackEmpty(SqStack S)
    {
    	if (S.top == -1)
    		return TRUE;
    	else
    		return FALSE;
    }
    /* 若栈不空,则用e返回S的栈顶元素,并返回OK;否则返回ERROR */
    SElemType GetTop(SqStack S)
    {
    	if (S.top == -1)
    		return 0;
    
    	return S.data[S.top];
    }
    /* 插入元素e为新的栈顶元素 */
    int Push(SqStack* S, SElemType e)
    {
    	if (S->top == MAXSIZE - 1) /* 栈满 */
    	{
    		return ERROR;
    	}
    	S->top++;				/* 栈顶指针增加一 */
    	S->data[S->top] = e;  /* 将新插入元素赋值给栈顶空间 */
    	return OK;
    }
    /* 若栈不空,则删除S的栈顶元素,用e返回其值,并返回OK;否则返回ERROR */
    int Pop(SqStack* S)
    {
    	if (S->top == -1)
    		return ERROR;
    	// *e = S->data[S->top];	/* 将要删除的栈顶元素赋值给e */
    	S->top--;				/* 栈顶指针减一 */
    	return OK;
    }
    /*******************************************************************************/
    /* 顺序栈结构 */
    typedef struct
    {
    	PLink data[MAXSIZE];
    	int top; /* 用于栈顶指针 */
    }PLinkStack;
    int PInitStack(PLinkStack* S)
    {
    	S->top = -1;
    	return OK;
    }
    /* 若栈S为空栈,则返回TRUE,否则返回FALSE */
    int PStackEmpty(PLinkStack S)
    {
    	if (S.top == -1)
    		return TRUE;
    	else
    		return FALSE;
    }
    /*清空栈*/
    int PClearStack(PLinkStack* S)
    {
    	S->top = -1;
    	return OK;
    }
    /* 若栈不空,则用e返回S的栈顶元素,并返回OK;否则返回ERROR */
    PLink PGetTop(PLinkStack S)
    {
    	if (S.top == -1)
    		return 0;
    
    	return S.data[S.top];
    }
    /* 插入元素e为新的栈顶元素 */
    int PPush(PLinkStack* S, PLink e)
    {
    	if (S->top == MAXSIZE - 1) /* 栈满 */
    	{
    		return ERROR;
    	}
    	S->top++;				/* 栈顶指针增加一 */
    	S->data[S->top] = e;  /* 将新插入元素赋值给栈顶空间 */
    	return OK;
    }
    /* 若栈不空,则删除S的栈顶元素,用e返回其值,并返回OK;否则返回ERROR */
    int PPop(PLinkStack* S)
    {
    	if (S->top == -1)
    		return ERROR;
    	//	*e = S->data[S->top];	/* 将要删除的栈顶元素赋值给e */
    	S->top--;				/* 栈顶指针减一 */
    	return OK;
    }
    /**************************************************************************/
    //输入操作
    void input(PNode* head) {
    	PNode* p;
    	char t;
    	scanf("%c", &t);
    	while (t != '\n') {
    		if (t >= 97 && t <= 122) {
    			p = (PNode*)malloc(sizeof(PNode));
    			p->data = t;
    			p->next = head->next;
    			head->next = p;
    		}
    		scanf("%c", &t);
    
    	}
    }
    //任意类型的输入
    void inputany(PNode* head) {
    	PNode* p;
    	char t;
    	scanf("%c", &t);
    	while (t != '\n') {
    		if (t >= 32 && t <= 126) {//ASCII可显示字符
    			p = (PNode*)malloc(sizeof(PNode));
    			p->data = t;
    			p->next = head->next;
    			head->next = p;
    			//	scanf("%c", &t);
    		}
    		scanf("%c", &t);
    
    	}
    }
    void Swap(PNode* p, PNode* q) {
    	PNode temp = *p;
    	temp.next = q->next;
    	q->next = p->next;
    	*p = *q;
    	*q = temp;
    }
    //排序
    void Sort(PNode* head) {
    	PNode* p, * q, * min;
    	if (!head) {
    		printf("空集");
    		return;
    	}
    	p = head->next;
    	min = p;
    	while (p)
    	{
    		min = p;
    		q = p;
    		while (q) {
    			if (q->data < min->data) {
    				min = q;
    			}
    			q = q->next;
    		}
    		Swap(p, min);
    		p = p->next;
    	}
    }
    //输出操作
    void out(PNode* head) {
    	Sort(head);
    	PNode* p;
    	if (!head) {
    		printf("空集");
    		return;
    	}
    	p = head->next;
    	while (p != NULL)
    	{
    		printf("%c", p->data);
    		p = p->next;
    	}
    	printf("\n");
    }
    //链表的清空
    int clearList(PLink L) {
    	PLink p, q;
    	p = L->next;
    	if (p == NULL) {
    		return 1;//为空
    	}
    	while (p) {
    		q = p;
    		p = p->next;
    		free(q);
    	}
    	L->next = NULL;
    	return 1;
    }
    
    //集合的并
    void and (PLink L1, PLink L2, PLink L3) {
    	if (L3->next != NULL)
    		clearList(L3);
    	PLink p, q, s;
    	//对空集的操作
    	if (!L1 || !L2) {
    		if (!L1) {
    			L3 = L2;
    		}
    		else if (!L2) {
    			L3 = L1;
    		}
    		else {
    			L3 = L1;
    		}
    	}
    	//对1号插入3中
    	p = L1->next;
    	while (p) {
    		q = L3->next;
    		while (q && (q->data != p->data)) {//C3号中不含有与1号相同的元素
    			q = q->next;
    		}
    		if (q == NULL) {
    			s = (PLink)malloc(sizeof(PNode));
    			s->data = p->data;
    			s->next = L3->next;
    			L3->next = s;
    		}
    		p = p->next;
    	}
    	//对2号插入3中
    	p = L2->next;
    	while (p) {
    		q = L3->next;
    		while (q && (q->data != p->data)) {//C3号中不含有与1号相同的元素
    			q = q->next;
    		}
    		if (q == NULL) {// //当q遍历完一次都没有找到的话,即q的最后为空时就可以将1中的一个元素插入3中
    			s = (PLink)malloc(sizeof(PNode));
    			s->data = p->data;
    			s->next = L3->next;
    			L3->next = s;
    		}
    		p = p->next;
    	}
    }
    //交集
    void intersection(PLink L1, PLink L2, PLink L3) {
    	if (L3->next != NULL)
    		clearList(L3);
    	PLink p, q, s, t;
    	//1
    	p = L1->next;//遍历1
    	while (p) {
    		q = L2->next;//遍历2
    		while (q) {
    			if (p->data == q->data)
    				break;//找到相同的就返回
    			else
    				q = q->next;
    		}
    		if (q) {//查找3号中有没有相同元素
    			s = L3->next;
    			while (s) {
    				if (s->data == p->data)
    					break;
    				else
    					s = s->next;
    			}
    			if (s == NULL) {
    				t = (PLink)malloc(sizeof(PNode));
    				t->data = p->data;
    				t->next = L3->next;
    				L3->next = t;
    			}
    		}
    		p = p->next;
    	}
    }
    //差集
    void difference(PLink L1, PLink L2, PLink L3) {
    	if (L3->next != NULL)
    		clearList(L3);
    	PLink p, q, s, t;
    	//1
    	p = L1->next;//遍历1
    	while (p) {
    		q = L2->next;
    		while (q) {
    			if (q->data == p->data)
    				break;
    			else
    				q = q->next;
    		}
    		if (q == NULL) {//说明2号遍历完了,并且有不一样的
    			s = L3->next;
    			while (s) {//3号中也没有的话就插入进去
    				if (s->data == p->data)
    					break;
    				else
    					s = s->next;
    			}
    			if (s == NULL) {
    				t = (PLink)malloc(sizeof(PNode));
    				t->data = p->data;
    				t->next = L3->next;
    				L3->next = t;
    			}
    		}
    		p = p->next;
    	}
    }
    //元素判定
    int checkElem(PLink L1, char c) {
    	PLink p;
    	p = L1->next;
    	while (p) {
    		if (p->data == c)
    			return 1;
    		p = p->next;
    	}
    	return 0;//此元素没有
    }
    //链表的添加
    void addElem(PLink L, char c) {
    	PLink t, p = L;
    	while (p->next)
    		p = p->next;
    	t = (PLink)malloc(sizeof(PNode));
    	t->data = c;
    	t->next = NULL;
    	p->next = t;
    }
    //补集
    void Neg(PLink L, PLink L3) {
    	if (L3->next != NULL)
    		clearList(L3);
    	PLink p = L;
    
    	int i = 0;
    	while (i < 26) {
    		if (!checkElem(p, i + 97))
    			addElem(L3, i + 97);
    		i++;
    	}
    }
    //任意类型的补集
    void Negany(PLink L, PLink L3) {
    	if (L3->next != NULL)
    		clearList(L3);
    	PLink p = L;
    
    	int i = 0;
    	while (i < 95) {
    		if (!checkElem(p, i + 32))
    			addElem(L3, i + 32);
    		i++;
    	}
    }
    //优先级判断
    int firstcheck(char a) {
    	if (a == '~') {
    		return 4;
    	}
    	else if (a == '*') {
    		return 3;
    	}
    	else if (a == '+' || a == '-') {
    		return 2;
    	}
    	else if (a == '(') {
    		return 1;
    	}
    	return 0;
    }
    //运算
    PLink choose(PLink A, PLink B, char a) {
    	PLink L3;
    	L3 = (PNode*)malloc(sizeof(PNode));
    	Init(L3);
    	switch (a)
    	{
    	case '+':
    		and (A, B, L3);
    		break;
    	case '-':
    		difference(A, B, L3);
    		break;
    	case '*':
    		intersection(A, B, L3);
    		break;
    	default:
    		break;
    	}
    	return L3;
    }
    //判断输入格式是否正确
    int IsInput(char str[]) {
    	int i = 0;
    	if (str[0] == '+' || str[0] == '-' || str[0] == '*'|| str[0] == ')') {
    		return 0;
    	}
    		
    	while (str[i] != '\0') {
    		if (str[i] == 'A' || str[i] == 'B') {//当是集合的时候,后面只能接运算符号“+,-,*”或回车符
    			if (str[i + 1] != '+' && str[i + 1] != '-' && str[i + 1] != '*'&&str[i+1]!='\0'&&str[i+1]!=')') {
    				return 0;
    			}
    		}
    		else if (str[i] == ')') {
    			if (str[i + 1] == '+' && str[i + 1] == '-' && str[i + 1] == '*' && str[i + 1] == '\0') {
    				return 0;
    			}
    		}
    		else if (str[i] == '~') {
    			if (str[i + 1] != 'A' && str[i + 1] != 'B' && str[i + 1] != '(') {
    				return 0;
    			}
    		}
    		else if (str[i] == '(') {
    			if (str[i + 1] != 'A' && str[i + 1] != 'B' && str[i + 1] != '~') {
    				return 0;
    			}
    		}
    		else if (str[i] == '+' || str[i] == '-' || str[i] == '*') {
    			if (str[i + 1] == '+' || str[i + 1] == '-' ||str[i + 1] == '*' || str[i + 1] == '\0' || str[i + 1] == ')') {
    				return 0;
    			}
    		}
    		i++;
    	}
    	return 1;
    }
    //混合运算
    void Mixed(PLink A, PLink B) {
    	SqStack s;//符号栈
    	PLinkStack p;//集合栈
    	//初始栈
    	InitStack(&s);
    	PInitStack(&p);
    	PLink temp, temp2;//作为中间栈储存链表
    	temp = (PNode*)malloc(sizeof(PNode));
    	Init(temp);
    	temp2 = (PNode*)malloc(sizeof(PNode));
    	Init(temp2);
    	SElemType c;
    	int i = 0, flag = 0;//代表没有括号
    	char str[MAXSIZE];
    	printf("请输入运算式:\n");
    	scanf("%s", &str);
    	while (!IsInput(str))
    	{
    		printf("输入格式错误,请重新输入运算式:\n");
    		scanf("%s", &str);
    
    	}
    
    	printf("输入结束\n");
    	int k = 0;
    	i = 0;
    	while (str[i] != '\0')
    	{
    		if (str[i] == '+' || str[i] == '-' || str[i] == '*') {
    			if (StackEmpty(s) == TRUE || GetTop(s) == '(' || PStackEmpty(p) == TRUE) {
    				if (StackEmpty(s) == TRUE || GetTop(s) == '(') {
    					Push(&s, str[i]);
    				}
    				if (PStackEmpty(p) == TRUE || GetTop(s) == '(') {
    					PPush(&p, temp);
    				}
    			}
    			else {
    				temp = choose(temp, PGetTop(p), GetTop(s));
    				PPop(&p);
    				PPush(&p, temp);
    				Pop(&s);
    				Push(&s, str[i]);
    			}
    			i++;
    		}
    		else if (str[i] == '(') {
    			Push(&s, str[i]);
    			i++;
    			k = 1;
    		}
    		else if (str[i] == ')') {
    			while (GetTop(s) != '(') {
    				temp = choose(temp, PGetTop(p), GetTop(s));
    				PPop(&p);
    				Pop(&s);
    			}
    			Pop(&s);//让"("出栈
    			if (GetTop(s) == '~') {
    				Neg(temp, temp2);
    				temp = temp2;
    				Pop(&s);//让"~"出栈
    			}
    			k = 0;
    			//temp[0] = temp[1];
    			i++;
    		}
    		else if (str[i] == '~') {
    			if (str[i + 1] == 'A') {
    				if (IsAny == 0) {
    					Neg(A, temp);
    				}
    				else {
    					Negany(A, temp);
    				}
    				i = i + 2;
    			}
    			else if (str[i + 1] == 'B') {
    				if (IsAny == 0) {
    					Neg(B, temp);
    				}
    				else {
    					Negany(B, temp);
    				}
    				i = i + 2;
    			}//当~(A+B)时
    			else if (str[i + 1] == '(') {
    				Push(&s, str[i]);
    				i++;
    			}
    			else {
    				printf("输入有误!“~”后面要有集合");
    				break;
    			}
    		}
    		//输入是集合的情况
    		else if (str[i] == 'A') {
    			temp = A;
    			i++;
    		}
    		else if (str[i] == 'B') {
    			temp = B;
    			i++;
    		}
    	}
    	while (StackEmpty(s) != TRUE)//符号栈不为空
    	{
    		temp = choose(PGetTop(p), temp, GetTop(s));
    		Pop(&s);
    		PPop(&p);
    	}
    	PClearStack(&p);
    	ClearStack(&s);
    	out(temp);
    }
    
    
    int main() {
    	/*FILE stream;
    	freopen_s(&stream, "in.txt", "r", stdin);*/
    	PLink L1, L2, L3;
    	L1 = (PLink)malloc(sizeof(PNode));
    	L2 = (PLink)malloc(sizeof(PNode));
    	L3 = (PLink)malloc(sizeof(PNode));
    	Init(L1);
    	Init(L2);
    	Init(L3);
    	printf("请选择\n1---限定元素:[‘a’..’z’]\n2---任意可显示类型\n");
    	char n[10];
    	do {
    		scanf("%s", &n);
    		getchar();
    		switch (n[0])
    		{
    		case '1':
    			printf("请输入集合Set1  ");
    			input(L1);
    			printf("请输入集合Set2  ");
    			input(L2);
    			IsAny = 0;
    			break;
    		case '2':
    			printf("请输入集合Set1  ");
    			inputany(L1);
    			printf("请输入集合Set2  ");
    			inputany(L2);
    			IsAny = 1;
    			break;
    		default:
    			printf("请检查是否输入错误\n");
    			break;
    		}
    	} while (n[0] != '1' && n[0] != '2');
    
    
    	printf("0----退出程序\n1---并集运算\n2---交集运算\n3---差集运算\n4---元素查找\n5---补集运算\n6---混合运算\n");
    	char i[10];
    	int flag = 1;
    	while (flag)
    	{
    		printf("请选择\n");
    		scanf("%s", &i);
    		switch (i[0]) {
    		case '0':
    			flag = 0;
    			break;
    		case '1':
    			and (L1, L2, L3);
    			printf("并集是:");
    			out(L3);
    			break;
    		case '2':
    			intersection(L1, L2, L3);
    			printf("交集是:");
    			out(L3);
    			break;
    		case '3':
    			difference(L1, L2, L3);
    			printf("(A-B)差集是:");
    			out(L3);
    			printf("(B-A)差集是:");
    			difference(L2, L1, L3);
    			out(L3);
    			break;
    		case '4':
    			printf("请输入查找的元素:  ");
    			char c;
    			scanf("%c", &c);
    			scanf("%c", &c);
    			if (checkElem(L1, c) && checkElem(L2, c)) {
    				printf("AB集合中存在%c\n", c);
    			}
    			else
    			{
    				if (checkElem(L1, c)) {
    					printf("A集合中存在%c\n", c);
    				}
    				else if (checkElem(L2, c)) {
    					printf("B集合中存在%c\n", c);
    				}
    				else {
    					printf("两个集合中都不存在%c\n", c);
    				}
    			}
    			break;
    		case '5':
    			printf("A集合的补集\n");
    			if (IsAny == 0) {
    				Neg(L1, L3);
    			}
    			else {
    				Negany(L1, L3);
    			}
    			out(L3);
    			printf("B集合的补集\n");
    			if (IsAny == 0) {
    				Neg(L2, L3);
    			}
    			else {
    				Negany(L2, L3);
    			}
    			out(L3);
    			break;
    		case '6':
    			Mixed(L1, L2);
    			break;
    		default:
    			printf("没这个选项,选错啦!");
    			continue;
    		}
    	}
    	return 0;
    }
    //测试数据
    //(A - B)* B
    //(~A - B)* B
    //(~A + B) - B
    //(~A + B) * B
    //~(A + B)
    
    展开全文
  • 编制一个能演示执行集合的并差运算的程序。 (1)设计集合的并差运算函数(集合的元素不能重复) (2)编制测试函数测试集合运算 (3)提示:以有序链表表示集合
  • 编制一个能演示执行集合的并差运算的程序.
  • C语言实现集合运算交并差补)

    万次阅读 多人点赞 2018-11-14 10:38:56
    C语言入门,写不好多多指教! //输入两个整数集合A、B,求出交集、并集以及B在A中余集,输入时按照大小顺序输入。 #include&lt;stdio.h&gt; #define MAX 1000//最大输入个数 int bubbleSort(int *A,...

    C语言入门,写的不好多多指教!
    这个是题目要求

    //输入两个整数集合A、B,求出交集、并集以及B在A中的余集,输入时按照大小顺序输入。
    
    #include<stdio.h>
    #define MAX 1000//最大输入个数
    
    int bubbleSort(int *A,int len)//冒泡排序
    {
       int i,j,t;
       for(i = 0;i < len-1;i++)
       {
          for(j = 0;j < len-i-1;j++)
          {
             if(A[j] > A[j+1])
             {
                t = A[j+1];
                A[j+1] = A[j];
                A[j] = t;
             }
          }
       }
    }
    //求并集,思路是把B集合赋值给buffer,然后从A中找B中不一样的
    //每找到一个,就接到buffer后面,最后再排序一下,就可以得到有顺序的并集
    //不确定能否找到一个不需要排序的方法??
    int unionSet(int *A,int *B,int lenA,int lenB)
    {
       int i,j;
       int flag,index = lenB;
       int *buffer = (int *)malloc(sizeof(int) * (lenA+lenB));//开辟内存存储A和B的并之后的集合
       for(i = 0;i< lenA+lenB;i++)//初始化buffer空间。
       {
          buffer[i] = -1;
       }
       for(i = 0;i < lenB;i++)
       {
          buffer[i] = B[i];
       }
       for(i = 0;i < lenA;i++)
       {
          flag = 1;
          for(j = 0;j < lenB;j++)
          {
             if(A[i] == B[j])
             {
                flag = 0;
             }
          }
          if(flag)
          {
             buffer[index] = A[i];
             index++;
          }
       }
       bubbleSort(buffer,lenA+lenB);
       for(i = 0;i < lenA+lenB;i++)
       {
          if(buffer[i] != -1)
          printf("%d ",buffer[i]);
       }
       printf("\n");
    }
    //交集思路:遍历数组A,和B中的每一个值比较,如果相同,flag = 1,就加入到buffer缓冲数组中,就可以找到所有的相同元素
    //因为输入本来就是有序的,所以不需要排序。
    int intersection(int *A,int *B,int lenA,int lenB)//交集
    {
       int i,j;
       int flag,index = 0,len = lenA > lenB ? lenA:lenB;
       int *buffer = (int *)malloc(sizeof(int) * len);
       for(i = 0;i < lenA;i++)
       {
          flag = 0;
          for(j = 0;j < lenB;j++)
          {
             if(A[i] == B[j])
                flag = 1;
          }
          for(j = 0;j < index;j++)
          {
             if(A[i] == buffer[j])
                flag = 0;
          }
          if(flag)
          {
             buffer[index] = A[i];
             index++;
          }
       }
    
       for(i = 0;i< index;i++)
          printf("%d ",buffer[i]);
       printf("\n");
    }
    //补集就就和交集相反
    int complementary(int *A,int *B,int lenA,int lenB)//补集(余集)
    {
       int i,j;
       int flag,index = 0;
       int *buffer = (int *)malloc(sizeof(int) * lenA);
       for(i = 0;i < lenA;i++)
       {
          flag = 1;
          for(j = 0;j < lenB;j++)
          {
             if(A[i] == B[j])
                flag = 0;
          }
          if(flag)
          {
             buffer[index] = A[i];
             index++;
          }
       }
       for(i = 0;i < index;i++)
          printf("%d ",buffer[i]);
       printf("\n");
    }
    
    int main()
    {
       int a[MAX],b[MAX];//存储输入的集合
       int i = 0,m = 0,n = 0;
       scanf("%d",&n);
       for(i = 0;i < n;i++)
          scanf("%d",&a[i]);
       //for(i = 0;i < n;i++)
       //   printf("%d ",a[i]);
       scanf("%d",&m);
       for(i = 0;i < n;i++)
          scanf("%d",&b[i]);
       printf("\n");
       intersection(a,b,n,m);//交集
       unionSet(a,b,n,m);//并集
       complementary(a,b,n,m);//补集(余集)
    }
    
    
    展开全文
  • 集合的并交运算(C语言》由会员分享,可在线阅读,更多相关《集合的并交运算(C语言(7页珍藏版)》请在人人...其次,根据集合的运算规则,利用单链表的有序性,设计差运算。 根据集合的运算规则,集合AAB中包...

    《集合的并交运算(C语言》由会员分享,可在线阅读,更多相关《集合的并交运算(C语言(7页珍藏版)》请在人人文库网上搜索。

    1、本文档如对你有帮助,请帮忙下载支持!题目一:集合的并、交运算首先,建立两个带头结点的有序单链表表示集合 A和B。须注意的是:利用 尾插入法建立有序单链表,输入数值是升序排列。其次,根据集合的运算规则,利用单链表的有序性,设计交、并和差运算。 根据集合的运算规则,集合AAB中包含所有既属于集合A又属于集合B的元素。 因此,须查找单链表A和B中的相同兀素并建立一个链表存于此链表中。遍历两链表的同时若元素相同时只将集合 A中的元素存于链表根据集合的运算规则,集合 AUB中包含所有或属于集合 A或属于集合B 的元素。因此, 中,若集合A中的下一个元素小于B中的元素就将A中的元素存于新建的链表 中。反之。

    2、将B中的兀素存于链表中。2所用数据结构线性结构利用链式存储结构实现集合的基本运算。3源代码分析#i ncludevstdio.h#in clude#defi ne ERROR 0#defi ne OK 1typ edef int Status;typ edef char Elemt ype;typ edef struct LNode线性表的链式存储结构Elemt ype data;struct LNode *n ext;Lno de,*Li nklist;#i ncludetext.hLNode* Greatlist(i nt *N,i nt n)建立一个带有头结点的单链表Lin klist 。

    3、p,q,L;L=p=(LNode *)malloc(sizeof(LNode);L- next=NULL;if(n !=0)for(i nt i=0;i vn ;i+)/尾部插入结点建立带有头q=(LNode *)malloc(sizeof(LNode);结点单链表/指针后移q-data=Ni; p-next=q; p=q; p-next=NULL; / 对于非空表,最后结点的指针域放空指针 return L;LNode* jiaoji(Linklist la,Linklist lb)/求两集合的交集Linklist pa,pb,pc,Lc;pa=la-next;pb=lb-next;/申请存。

    4、储空间Lc=(Linklist)malloc(sizeof(LNode);Lc-next=NULL;pc=Lc; while(pa&pb)if(pa-data=pb-data)pc-next=(Linklist)malloc(sizeof(LNode);/ 若相等就申请存储空间链到 Lc 上pc=pc-next; pc-data=pa-data;pa=pa-next;/la,lb 的指针后移pb=pb-next;else if(pa-datapb-data)/若pa所指的元素大于 pb所指的元素 pb指针后移pb=pb-next;elsepa=pa-next;pc-next=NULL;/ 最后。

    5、给 pc 的 next 赋 NULL return Lc;LNode* bingji(Linklist la,Linklist lb) / 求两集合的并集Linklist pa,pb,pc,lc;pa=la-next;pb=lb-next;lc=(Linklist)malloc(sizeof(LNode); lc-next=NULL;pc=lc;while(pa&pb)if(pa-data=pb-data)pc-next=(Linklist)malloc(sizeof(LNode);/ 若 所指的元素申请空间将值存入链表lc,pa,pb 指针后移pc=pc-next;pc-data=pa-da。

    6、ta;pa=pa-next;pb=pb-next;else if(pa-datapb-data)pc-next=(Linklist)malloc(sizeof(LNode);/ 若 所指的元素申请空间将值存入链表lc,pb 指针后移pc=pc-next;pc-data=pb-data;pb=pb-next;elsepc-next=(Linklist)malloc(sizeof(LNode);/ 若所指的元素申请空间将值存入链表Ic, pa指针后移pc=pc-next;pc-data=pa-data; pa=pa-next;pc-next=pa?pa:pb;return Ic;void Prin。

    7、t_LinkList(LinkIist L)/输出元素LinkIist p=L-next;while( P)/链表不为空时输出链表中的值printf( %3c ,p-data);p=p-next;printf( n );papapa所指的元素等于所指的元素大于所指的元素小于pbpbpbvoid main()Linklist L1,L2,La,Lb;int A4=a,b,c,f;int B4=c,d,e,f;printf(1)含多个结点的顺序表 a , b和cc, n e , f printf(建立链表L1为n);L1=Greatlist(A,4);Print_LinkList(L1);prin。

    8、tf(建立链表L2为n);L2=Greatlist(B,4);Print_LinkList(L2);printf( 两链表的交集为: n);La=jiaoji(L1,L2);Print_LinkList(La);printf( 两链表的并集为: n);Lb=bingji(L1,L2);Print_LinkList(Lb);printf(2)含一个结点的顺序表 a和空表n);int A11=a;int B11=0;printf(建立链表L1为n);L1=Greatlist(A1,1);Print_LinkList(L1);printf(建立链表L2为n);L2=Greatlist(B1,0);P。

    9、rint_LinkList(L2);printf( 两链表的交集为: n);La=jiaoji(L1,L2);Print_LinkList(La);printf(两链表的并集为:n);Lb=bingji(L1,L2);Print_LinkList(Lb);printf(3)2 个空表 n);int A21=0;int B21=0;printf(建立链表L1为n);L1=Greatlist(A2,0);Print_LinkList(L1);printf(建立链表L2为n);L2=Greatlist(B2,0);Print_LinkList(L2);printf(两链表的交集为:n);La=jia。

    10、oji(L1,L2);Print_LinkList(La);printf( 两链表的并集为: n);Lb=bingji(L1,L2);本文档如对你有帮助,请帮忙下载支持!Print_LinkList(Lb);free(L1);free(L2);free(La);free(Lb);4 测试数据及运行结果(1) 含多个结点的顺序表a , b和t Cc, : d , e , f(2) 含一个结点的顺序表 a和空表(3)2个空表5 算法分析1)2)LNode* Greatlist()/ 尾插法建立链表算法的时间复杂度为0 (n), n为输入元素个数。LNode* jiaoji(Linklist la,Linklist lb)算法时间复杂度为0 (m+n), m为集合A元素个数,n为集合B元素个数。LNode* bingji(Linklist la,Linklist lb)算法时间复杂度为0 (m+n), m为集合A元素个数,n为集合B元素个数。 4) void Print_LinkList(Linklist L)算法时间复杂度为0 (n) n为集合元素个数。3。

    展开全文
  • 数据结构–C语言链表实现集合的运算!(数组) 效果如图: 要求: 从程序完善性上考虑,集合元素输入时,要有检查元素重复的功能,每个集合中不允许有重复的元素。集合可以用数组也可以用链表存储。 ...

    数据结构–C语言实现集合的(并,交,差)运算!(数组)

    效果如图:
    效果图
    要求:
    从程序完善性上考虑,集合元素输入时,要有检查元素重复的功能,每个集合中不允许有重复的元素。集合可以用数组也可以用链表存储。
    实现交、并、差运算时,分别把代码写成函数的形式,即实现交运算的函数,实现并运算的函数,实现差运算的函数,在主函数中分别调用三个函数。
    使用菜单形式对应各个操作,应允许用户反复查看结果,想结束程序时,输入负数结束,使其编成一个完整的小软件。菜单参考示例如下:
    1—输入集合A和B
    2—求集合A交B
    3—求集合A并B
    4—求集合A-B
    退出,输入一个负数!
    验收/测试用例:
    输入: A={1,2,3,4,5}
    B={3,4,5,6,7}
    要注意输入的过程中,每输入一个元素都要检查输入的这个元素是否和前面的元素重复,如果重复,要求用户重新输入当前元素。
    验收测试时要测试这种重复的情况。
    输出 A交B={3, 4, 5}
    A并B={1,2,3,4,5,6,7}
    A-B={1, 2}
    代码部分

    #include <stdio.h> 
    int a[50]={0},b[50]={0},c[50]={0},d[50]={0},e[50]={0};
    
    //显示输出
    void show (){    
     printf("\t\t--------------集合运算--------------\n");
     printf("\n");
     printf("\t\t\t 1---输入集合A和B\n");
     printf("\t\t\t 2---求集合A交B\n");
     printf("\t\t\t 3---求集合A并B\n");
     printf("\t\t\t 4---求集合A-B\n");
     printf("\t\t\t 退出,输入一个负数!");
     printf("\n");
     printf("\t\t------------------------------------\n");
     printf("\n");
    }
    
    //输入集合A和B 
    void input(int x,int y){ 
     int i,j;
     printf("请输入A的元素");
     for(i=0;i<x;i++){     
      scanf("%d",&a[i]);
      getchar();
      for(j=0;j<i;j++){    //通过循环判断进行查重 
       if(a[i]==a[j]){    
        printf("输入错误!请重新输入");
        a[i]=0;
        i-- ;
       }
      }
     }  
     printf("请输入B的元素");
     for(i=0;i<y;i++){     
      scanf("%d",&b[i]);
      getchar();
      for(j=0;j<i;j++){    //通过循环判断进行查重 
       if(b[i]==b[j]){    
        printf("输入错误!请重新输入");
        b[i]=0; 
       }
      }
     } 
    }
    
    //求集合A交B,因为交集会多次使用,故与输出分开。 
    int hand(int x,int y){
     int i,j,k=0;
     for(i=0;i<x;i++){
      for(j=0;j<y;j++){
       if(a[i]==b[j]){
        c[k]=a[i];
        k++;
       }
      }
     }
     return k;
    } 
    
    //输出交集
    void outhand(int k){
     int i;
     printf("A交B={");
     for(i=0;i<k-1;i++){
      printf("\t %d,",c[i]);
     } 
     printf("\t %d}\n",c[k-1]);
    } 
    
    //求集合A并B
    void combine(int x,int y,int k){
     int i,j,m=0,n;
     int com[50]={0}; 
     for(i=0;i<x;i++){
      d[m]=a[i];
      m++;
     }
     for(i=0;i<y;i++){
      d[m]=b[i];
      m++;   //m为a和b集合的总的元素个数 
     }
     /*
     for(i=0;i<x+y-k;i++){    //x+y-k为并集的实际元素个数 ,且该循环除去重复元素 
      for(j=m;j>i;j--){
       if(d[j]==d[i]){
        d[j]=d[j+1]; //用重复元素后一位元素覆盖该元素 
        i--;   //从新进行该轮循环,消除上一步带来的多个元素重复的影响 
        break;   //跳出里层for循环 
       }
      }
     }
     */
     for(i=0;i<x+y-k;i++){    //x+y-k为并集的实际元素个数 ,且该循环除去重复元素 
      for(j=i+1;j<m;j++){
       if(d[j]==d[i]){
        for(n=j;n<m;n++){
         d[n]=d[n+1];
        }
        break;
       }
      }
     }
     printf("A并B={");
     for(i=0;i<x+y-k-1;i++){
      printf("\t %d,",d[i]);
     } 
     printf("\t %d}\n",d[x+y-k-1]);
    }
    
    //求集合A-B 
    void reduce(int x,int k){
     int i,j,m;
     for(i=0;i<x;i++){
      e[i]=a[i];
     }
     for(i=0;i<x-k;i++){  //思路同并集中除去重复元素 
      for(j=0;j<k;j++){
       if(e[i]==c[j]){
        for (m=i;m<x;m++){  //将重复后所有元素前移 
         e[m]=e[m+1]; 
        }
        i--;
        break;
       }
      }
     }
     printf("A-B={");
     for(i=0;i<x-k-1;i++){
      printf("\t %d,",e[i]);
     } 
     printf("\t %d}\n",e[x-k-1]);
    }
    
    int main(){
     int x,y,i,j,k,choice;
     while(1){
      show();
      printf("请选择你需要进行的操作\n");
      scanf("%d",&choice);
      if(choice<0){
       printf("已退出。");
       return 0;
      }else{
       switch(choice){
        case 1:
         printf("请输入A集合中元素个数\n");
         scanf("%d",&x);
         printf("请输入B集合中元素个数\n");
         scanf("%d",&y);
         input(x,y);
         k=hand(x,y);
         printf("请按回车继续!\n");
         getchar();
         system("cls");
         break;
        case 2:
         outhand(k);
         printf("请按回车继续!\n");
         getchar();
         getchar();
         system("cls");
         break;
        case 3:
         combine(x,y,k);
         printf("请按回车继续!\n");
         getchar();
         getchar();
         system("cls");
         break;
        case 4:
         reduce(x,k);
         printf("请按回车继续!\n");
         getchar();
         getchar();
         system("cls");
         break;
        default :
         printf("输入有误!\n");
         printf("请按回车继续!\n");
         getchar();
         getchar();
         system("cls");
         break;
       }
      }
     }
     return 0;
    }
    
    

    该代码只是运用普通数组实现,未运用到动态数组或链表,因此若集合元素超过50则无法使用,(其实这个题更适合用链表做,毕竟链表更容易进行删除。)欢迎各位大佬指正,后续会写用链表实现的代码,写好后会在下面附加链接,链接已送上,欢迎指正。
    https://blog.csdn.net/e_t_e_r_n_i_t_y/article/details/108940494

    展开全文
  • 集合交并差运算

    2012-04-24 13:32:32
    C语言 数据结构 完成连队列 集合 运算
  • 实现差运算时,分别把代码写成函数形式,即实现运算函数,实现运算函数,实现差运算的函数,在主函数中分别调用三个函数。 使用菜单形式对应各个操作,应允许用户反复查看结果,想结束程序时,...
  • 编写程序实现两个集 合的并,相对补,对称,幂集的运算并判断两个集合是否相等
  • C语言实现两个集合的并、补运算

    千次阅读 多人点赞 2019-07-17 19:46:37
    题目:C语言实现两个集合的并、补运算 环境:DEV C++ 结果图如下: 完整代码如下: #include<stdio.h> #include<stdlib.h> #define TRUE 1 #define FALSE 0 #define OK 1 #define ...
  • 实用文案 问题描述 编制一个能演示执行集合的并交差运算的程序 基本要求 1 集合的元素限定为小写字母字符 [ 'a'z' ] 2 演示程序以用户和计算机对话的方式执行 测试数据 实现提示 以有序链表表示集合 代码过程 1先...
  • 集合运算C语言代码及报告一,问题重述集合中的元素为小字母a-小写字母z,实现以下运算:实现集合表示和集合的运算(、补)判断集合之间、元素和集合之间的关系二,源程序及注释#include #include #include #...
  • 任务描述 ...②输出集合A与B的并、相对补、差、对称差运算。 ③输出集合A与B是否相等断定结果。 ④输出集合A与B幂集。#include #include<stdlib.h>int unionSets(int *A, int *B, int lenA
  • C语言实现集合的交,,

    千次阅读 2007-05-23 12:06:00
    C语言实现集合的交,,差作者:Raining_C 来源:http://blog.csdn.net/Raining_CN 【问题描述】 编制一个能演示执行集合的、交和差运算的程序【基本要求】 (1)集合的元素限定为小写字母字符[ a......z ] (2...
  • STL中集合的并 运算声明集合的介绍模板定义并集运算模板定义使用举例 声明 今天一直在学习STL, 学习目录参考的是C语言编程网, 内容主要参考的是这个网站。 我学习的流程是按照C语言编程网的目录结构, 学...
  • 离散数学实验报告专业班级:12 级计算机本部一班 姓名:鲍佳珍学号: 201212201401016 实验成绩:1....3.【实验内容】编程实现集合的交和补运算。4、【实验要求】C或C++语言编程实现5. 【算...
  • 内容 已知所给集合 A 和 B,求 A 与 B 并集 C(C=A∪B) ...*离散数学中简单的集合运算,代码由C语言编写,思路非常简单,代码如下: #include<stdio.h> int Interection(int a[],int b[...
  • 课程设计的内容及要求: (一)主要内容 1.任务描述 编制一个能够演示执行集合操作的程序: ① 能够实现集合的并差运算; ② 实现集合的元素判定和子集判定运算; ③ 求集合的补集。
  • C语言实现集合运算

    2014-04-02 15:58:14
    有结构体和链表实现任意集合的并差运算,有中文注释。

空空如也

空空如也

1 2 3
收藏数 51
精华内容 20
关键字:

c语言集合的交并差运算

c语言 订阅