您的位置：360文档中心› C语言实现集合的交,并,差

C语言实现集合的交,并,差

合集下载

c语言程序设计课程设计选题 (1)

c语言程序设计课程设计选题 (1)

《C语言程序设计》课程设计课题表一、A类1.职工信息管理系统设计2.职工信息包括职工号、姓名、性别、年龄、学历、工资、住址、电话等（职工号不重复）。

试设计一职工信息管理系统，使之能提供以下功能：3.1、职工信息录入功能(职工信息用文件保存)－－输入4.2、职工信息浏览功能－－输出5.3、职工信息查询功能－－算法6.查询方式：按学历查询、按职工号查询、条件组合查询7.职工信息删除、修改功能(可选项)8.图书信息管理系统设计9.图书信息包括：登录号、书名、作者名、分类号、出版单位、出版时间、价格等。

10.试设计一图书信息管理系统，使之能提供以下功能：11.1、图书信息录入功能(图书信息用文件保存)－－输入12.2、图书信息浏览功能－－输出13.3、图书信息查询功能－－算法14.查询方式：按书名查询、按作者名查询、条件组合查询15.图书信息的删除与修改(可选项)16.图书管理系统设计17.图书管理信息包括：图书名称、图书编号、单价、作者、存在状态、借书人姓名、性别、学号等18.功能描述：19.1、新进图书基本信息的输入。

20.2、图书基本信息的查询。

21.3、对撤消图书信息的删除。

22.4、为借书人办理注册。

23.5、办理借书手续。

24.6、办理还书手续25.要求：使用文件方式存储数据。

26.实验设备管理系统设计27.实验设备信息包括：设备编号，设备种类(如：微机、打印机、扫描仪等等)，设备名称，设备价格，设备购入日期，是否报废，报废日期等。

28.主要功能：29.1、能够完成对设备的录入和修改30.2、对设备进行分类统计31.3、设备的破损耗费和遗损处理32.4、设备的查询33.要求：使用文件方式存储数据。

34.学生信息管理系统设计35.学生信息包括：学号，姓名，年龄，性别，出生年月，地址，电话，E-mail等。

试设计一学生信息管理系统，使之能提供以下功能：36.1、系统以菜单方式工作37.2、学生信息录入功能（学生信息用文件保存）－－输入38.3、学生信息浏览功能－－输出39.4、学生信息查询功能－－按学号查询、按姓名查询、40.5、学生信息的删除与修改(可选项)41.要求：使用文件方式存储数据。

C语言程序设计第五章

C语言程序设计第五章
通过编写程序，实现对数组的访问、修改 、排序等操作。例如，实现一个程序，将 一个数组中的所有元素进行排序，或者找 到数组中的最大值和最小值。
05 案例分析
案例一：条件语句在程序中的应用
总结词
条件语句是C语言中用于根据不同条件执行不同操作的语句，通过if、else if和else关键 字实现。
详细描述
编程练习二：循环语句应用
总结词
理解并掌握while和for循环的使用
详细描述
通过编写程序，实现重复执行某段代 码直到满足特定条件，或者根据需要 重复执行某段代码指定次数。例如， 计算1到100的累加和，或者打印出0 到99的所有偶数。
编程练习三：数组操作应用
总结词
理解并掌握数组的基本操作
VS
详细描述
详细描述
数组在程序中用于存储和处理同一种类型的 数据元素，例如存储一组学生的成绩、计算 一组数据的平均值等。数组操作包括数组的 声明、初始化、访问和修改等。通过循环语 句可以方便地遍历数组元素并进行处理。数 组操作在程序中具有广泛的应用，是C语言
中重要的数据结构和算法之一。
06 总结与展望
本章总结
详细描述
C语言中的数组是一种存储相同类型元素的线性数据结构。可以通过索引访问数 组元素，进行赋值、交换、排序等操作。同时，C语言还提供了字符串操作函数， 如strcpy、strcat、strlen等。
语法点三：数组操作
01
示例代码
02
```c
int array[10]; // 声明一个包含10个整数的数组
详细描述
循环语句在程序中用于重复执行一段代码， 例如打印1到10的数字、计算一定数量的累 加和等。循环语句可以嵌套使用，以实现更 复杂的循环结构和算法。循环语句通常与条 件语句结合使用，以控制循环的执行条件和 次数。

集合的交并差运算

集合的交并差运算

#include<stdio.h>#include<malloc.h>#include<stdlib.h>struct set{int coef;struct set *next;};void createlist_p(struct set *&p,int n){int i;struct set *L;p=(struct set *)malloc(sizeof(set));p->next=NULL;for(i=n;i>0;i--){L=(struct set *)malloc(sizeof(set));牰湩晴尨请输入该集合中第%d个整数元素:,n-i+1); scanf(%d,&L->coef);L->next=p->next;p->next=L;}}//生成新链表用于存放两集合中的元素void printlist_p(struct set *&p){struct set *L;int i;L=p->next;晩??瀠楲瑮?该表为空!\n);while(L!=NULL){printf(%d ,L->coef);L=L->next;i++;}printf(\);}//打印输入的两集合中的元素void Addset(struct set *&p,struct set *&q,struct set *&r) {struct set *k,*m,*n;r=(struct set *)malloc(sizeof(set));r->next=NULL;k=p->next;for(;k;){m=(struct set *)malloc(sizeof(set));m->next=r->next;r->next=m;m->coef=k->coef;k=k->next;}//把第一个集合中的元素放在新集合中k=q->next;m=(struct set *)malloc(sizeof(set));m->next=r->next;r->next=m;m->coef=k->coef;k=k->next;for(;k;){for(n=r->next;(k->coef!=n->coef)&&n->next;){n=n->next;}//与新集合中的元素比较if((k->coef!=n->coef)&&!(n->next)){m=(struct set *)malloc(sizeof(set));m->next=r->next;r->next=m;m->coef=k->coef;}k=k->next;}//对第二个集合中的元素进行分析}//求A∪Bvoid Subset(struct set *&p,struct set *&q,struct set *&r){ struct set *k,*m,*n;r=(struct set *)malloc(sizeof(set));r->next=NULL;n=q->next;for(;n;){m=p->next;for(;(m->coef!=n->coef)&&m->next;){m=m->next;}if(m->coef==n->coef) {k=(struct set *)malloc(sizeof(set));k->next=r->next;r->next=k;k->coef=m->coef;}n=n->next;}}//求A∩Bvoid Intset(struct set *&p,struct set *&q,struct set *&r){ struct set *k,*m,*n;r=(struct set *)malloc(sizeof(set));r->next=NULL;m=p->next;for(;m;){n=q->next;for(;(m->coef!=n->coef)&&n->next;){n=n->next;}if(!n->next&&(m->coef!=n->coef)) {k=(struct set *)malloc(sizeof(set));k->next=r->next;r->next=k;k->coef=m->coef;}m=m->next;}}//求A-Bvoid bangzhu(){printf(\\t\t\t***********************************); printf(\\t\t\t* 求集合的交并差*);printf(\\t\t\t*********************************\n);}void main(){struct set *p,*q,*r;int m,n,node;bangzhu();for(;;){do{牰湩晴尨请输入您要选择操作的代码:\n);printf(：求两集合的并A∪B\n);printf(：求两集合的交A∩B\n);printf(：求两集合的差A-B\n);printf(：退出该程序\n);scanf(%d,&node);} while(node<0||node>3);if(node==0) exit(1);printf(\\t\t/*请输入集合A中元素的个数：*/\n);scanf(%d,&m);createlist_p(p,m);printf(\\t\t/*请输入集合B中元素的个数：*/\n);scanf(%d,&n);createlist_p(q,n);牰湩晴尨集合A中元素为:);printlist_p(p);牰湩晴尨集合B中元素为:);printlist_p(q);while(node<0||node>3);switch(node){case 1: Addset( p,q,r);printf(A∪B:\n);printlist_p(r);break;case 2: Subset( p,q,r);printf(A∩B:\n);printlist_p(r);break;case 3: Intset(p,q,r); printf(A-B:\n);printlist_p(r);break;}printf(\);}}可以了楼上方法是正确的，学习!把分给楼上主要原因是C程序中使用了C语言不支持的引用所致，修改如下：//---------------------------------------------------------------------------#include<stdio.h>#include<malloc.h>#include<stdlib.h>typedef struct set{int coef;struct set *next;} set ;void createlist_p(struct set **p,int n){int i;struct set *L;*p=(struct set *)malloc(sizeof(set));(*p)->next=NULL;for(i=n;i>0;i--){L=(struct set *)malloc(sizeof(set));牰湩晴尨请输入该集合中第%d个整数元素:,n-i+1); scanf(%d,&L->coef);L->next=(*p)->next;(*p)->next=L;}}//生成新链表用于存放两集合中的元素void printlist_p(struct set **p){struct set *L;int i=0;L=(*p)->next;晩??瀠楲瑮?该表为空!\n);while(L!=NULL){printf(%d ,L->coef);L=L->next;i++;}printf(\);}// 打印输入的两集合中的元素void Addset(struct set **p,struct set **q,struct set **r) {struct set *k,*m,*n;*r=(struct set *)malloc(sizeof(set));(*r)->next=NULL;k=(*p)->next;for(;k;){m=(struct set *)malloc(sizeof(set));m->next=(*r)->next;(*r)->next=m;m->coef=k->coef;k=k->next;}//把第一个集合中的元素放在新集合中k=(*q)->next;m=(struct set *)malloc(sizeof(set));m->next=(*r)->next;(*r)->next=m;m->coef=k->coef;k=k->next;for(;k;){for(n=(*r)->next;(k->coef!=n->coef)&&n->next;){n=n->next;}//与新集合中的元素比较if((k->coef!=n->coef)&&!(n->next)){m=(struct set *)malloc(sizeof(set));m->next=(*r)->next;(*r)->next=m;m->coef=k->coef;}k=k->next;}//对第二个集合中的元素进行分析}//求A∪Bvoid Subset(struct set **p,struct set **q,struct set **r){ struct set *k,*m,*n;(*r)=(struct set *)malloc(sizeof(set));(*r)->next=NULL;n=(*q)->next;for(;n;){m=(*p)->next;for(;(m->coef!=n->coef)&&m->next;){m=m->next;}if(m->coef==n->coef) {k=(struct set *)malloc(sizeof(set));k->next=(*r)->next;(*r)->next=k;k->coef=m->coef;}n=n->next;}}//求A∩Bvoid Intset(struct set **p,struct set **q,struct set **r){ struct set *k,*m,*n;(*r)=(struct set *)malloc(sizeof(set));(*r)->next=NULL;m=(*p)->next;for(;m;){n=(*q)->next;for(;(m->coef!=n->coef)&&n->next;){n=n->next;}if(!n->next&&(m->coef!=n->coef)) {k=(struct set *)malloc(sizeof(set));k->next=(*r)->next;(*r)->next=k;k->coef=m->coef;}m=m->next;}}//求A-Bvoid bangzhu(void){printf(\\t\t\t***********************************);printf(\\t\t\t* 求集合的交并差*);printf(\\t\t\t*********************************\n);}void main(){struct set *p,*q,*r;int m,n,node;bangzhu();for(;;){do{牰湩晴尨请输入您要选择操作的代码:\n);printf(：求两集合的并A∪B\n);printf(：求两集合的交A∩B\n);printf(：求两集合的差A-B\n); printf(：退出该程序\n);scanf(%d,&node);}while(node<0||node>3);if(node==0) exit(1);printf(\\t\t/*请输入集合A中元素的个数：*/\n);scanf(%d,&m);createlist_p(&p,m);printf(\\t\t/*请输入集合B中元素的个数：*/\n);scanf(%d,&n);createlist_p(&q,n);牰湩晴尨集合A中元素为:);printlist_p(&p);printf( 集合B中元素为:);printlist_p(&q);//while(node<0||node>3);switch(node){case 1: Addset( &p,&q,&r);printf(A∪B:\n);printlist_p(&r);break; B:\n);printlist_p(&r);break; ∩case 2: Subset( &p,&q,&r);printf(A．case 3: Intset(&p,&q,&r); printf(A-B:\n);printlist_p(&r);break;}printf(\);}}//---------------------------------------------------------------------------。

c语言程序求集合的并集,交集,差集运算

c语言程序求集合的并集,交集,差集运算

C语言是一种广泛应用的计算机程序设计语言，它具有高效、灵活、可移植等特点，因此在计算机科学领域被广泛应用。

本篇文章将探讨在C语言中如何求集合的并集、交集和差集运算。

一、集合的概念集合是数学中重要的概念，它是由元素组成的无序的集合体。

在计算机科学中，我们常常需要对集合进行各种操作，比如求并集、交集、差集等。

二、集合的表示方法在C语言中，我们可以使用数组来表示集合。

数组是一种非常基础的数据结构，它由相同类型的元素组成的有序集合。

我们可以通过定义数组来表示一个集合，并通过遍历数组来进行各种集合运算。

三、集合的并集运算集合A和集合B的并集运算是指将A和B中的所有元素放在一起组成一个新的集合。

在C语言中，我们可以通过遍历两个数组，将它们的元素放在一个新的数组中即可实现并集运算。

下面是C语言中求两个集合的并集运算的示例代码：```#include <stdio.h>int m本人n() {int setA[] = {1, 2, 3, 4, 5};int setB[] = {3, 4, 5, 6, 7};int setSize = 5;int setUnion[10];int unionSize = 0;for (int i = 0; i < setSize; i++) {setUnion[unionSize++] = setA[i]; }for (int i = 0; i < setSize; i++) {int found = 0;for (int j = 0; j < setSize; j++) {if (setB[i] == setA[j]) {found = 1;break;}}if (!found) {setUnion[unionSize++] = setB[i];}}// 输出并集for (int i = 0; i < unionSize; i++) {printf("d ", setUnion[i]);}return 0;}```以上代码中，我们定义了两个集合setA和setB，分别表示集合A和集合B，然后通过遍历这两个数组，将它们的元素放入一个新的数组setUnion中。

C语言集合的实现

C语言集合的实现

C语言集合的实现C语言是一种通用的程序设计语言，提供了丰富的数据结构和算法库。

在C语言中，集合是一种存储不重复元素的数据结构，常用于需要存储、查询和操作一组不同元素的场景。

本文将介绍C语言中集合的实现方式，并详细解释其原理和应用。

1.集合的定义集合是一种不包含重复元素的容器，没有特定的顺序。

在C语言中，可以使用数组或链表等数据结构来实现集合。

集合通常有以下几个基本操作：插入元素、删除元素、判断元素是否存在、求并集、求交集、求差集等。

2.集合的实现方式2.1使用数组实现集合使用数组实现集合比较简单，只需要定义一个固定大小的数组，然后使用元素的值作为下标来标记元素是否存在。

例如，要存储范围在0-9之间的整数集合，可以定义一个大小为10的数组，数组下标代表元素值，数组元素的值用于表示元素是否存在。

下面是使用数组实现集合的示例代码：```c#define SIZE 10//初始化集合void initSet(int set[])for (int i = 0; i < SIZE; i++)set[i] = 0;}//插入元素void insertElement(int set[], int element) if (element >= 0 && element < SIZE)set[element] = 1;}//删除元素void deleteElement(int set[], int element) if (element >= 0 && element < SIZE)set[element] = 0;}//判断元素是否存在int isElementExist(int set[], int element) if (element >= 0 && element < SIZE)return set[element];} elsereturn 0;}//打印集合void printSet(int set[])for (int i = 0; i < SIZE; i++) if (set[i] == 1)printf("%d ", i);}}int maiint set[SIZE];initSet(set);insertElement(set, 1); insertElement(set, 3); insertElement(set, 5); deleteElement(set, 3);printf("集合中的元素为："); printSet(set);return 0;```这段代码中，先定义了一个大小为10的数组作为集合的存储空间。

c语言的集合的交并补

c语言的集合的交并补
bianli(bing, num2);
printf("}\n");
printf("A-B={");
bianli(bu, num3);
printf("}\n");
return 0;
}
通过键盘，分别输入两个数据元素类型为正整数的集合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}
}
}
int main(){
int c;
int a[N],count1,b[N],count2;//a，b两个集合，以及数量
int jiao[N],bing[2*N],bu[N];//交并补三个集合
int num1=0,num2=0,num3=0;
printf("请输入第一个集合:\n");
for(int i=0;i<N;i++){
for(int i=0;i<=count1;i++){//用b数组遍历bing
for(int j=0;j<=count2;j++){
if(b[i]==bing[j])
break;
if(j==count2)
bing[num2++]=b[i];
}
}
//求a对b的补集
for(int i=0;i<=count1;i++){
for(int j=0;j<=count2;j++){

离散数学集合的运算实验报告

离散数学集合的运算实验报告

大连民族学院计算机科学与工程学院实验报告实验题目：集合的运算课程名称：离散数学实验类型：□演示性□验证性□操作性□设计性□综合性专业：网络工程班级：网络111班学生姓名：张山学号：2011083123实验日期：2013年12月22日实验地点：I区实验机房实验学时：8小时实验成绩：指导教师签字：年月日老师评语：1实验题目：集合的运算实验原理：1、实验内容与要求：实验内容：本实验求两个集合间的运算，给定两个集合A、B，求集合A与集合B之间的交集、并集、差集、对称差集和笛卡尔乘积。

实验要求：对于给定的集合A、B。

用C++/C语言设计一个程序（本实验采用C++），该程序能够完成两个集合间的各种运算，可根据需要选择输出某种运算结果，也可一次输出所有运算结果。

2、实验算法：实验算法分为如下几步：（1）、设计整体框架该程序采取操作、打印分离（求解和输出分开）的思想。

即先设计函数求解各部分运算并将相应结果传入数组（所求集合）中，然后根据需要打印运算结果。

（2）、建立一个集合类（Gather）类体包括的数组a、b、c、d、e、f、g分别存储集合A、B以及所求各种运算的集合。

接口（实现操作的函数）包括构造函数，菜单显示函数，求解操作函数，打印各种运算结果等函数。

（3）、设计类体中的接口构造函数：对对象进行初始化，建立集合A与集合B。

菜单显示函数：设计提示选项，给使用者操作提示。

操作函数：该函数是程序的主题部分，完成对集合的所有运算的求解过程，并将结果弹入（存入）对应数组（集合）中，用于打印。

具体操作如下：21*求交集：根据集合中交集的定义，将数组a、b中元素挨个比较，把共同元素选出来，并存入数组c（交集集合）中，即求得集合A、B的交集。

2*求并集：根据集合中并集的定义，先将数组a中元素依次存入数组g（并集集合）中，存储集合A中某元素前，先将其与已存入g中的元素依次比较，若相同则存入下一个元素，否则直接存入g中，直到所有A中元素存储完毕。

实现两个集合的相关运算c语言

实现两个集合的相关运算c语言

实现两个集合的相关运算c语言实现两个集合的相关运算（C语言）在编程中，集合是一种常见的数据结构，用于存储一组不重复的元素。

集合的相关运算包括并集、交集、差集等，可以帮助我们对数据进行处理和分析。

本文将以C语言为例，介绍如何实现两个集合的相关运算。

一、集合的定义与表示在C语言中，可以使用数组来表示集合。

数组的每个元素对应集合中的一个元素，而数组的索引则代表元素的位置。

为了实现集合的相关运算，我们需要定义一个结构体来存储集合的信息，包括集合的大小和元素数组。

下面是一个示例的集合结构体定义：```c#define MAX_SIZE 100typedef struct {int size; // 集合的大小int elements[MAX_SIZE]; // 元素数组} Set;```二、集合的初始化在进行集合运算之前，我们首先需要初始化两个集合。

集合的初始化包括设置集合的大小和填充元素数组。

下面是一个示例的集合初始化函数：```cvoid initSet(Set* set, int size, int elements[]) {set->size = size;for (int i = 0; i < size; i++) {set->elements[i] = elements[i];}}```三、集合的并集运算集合的并集运算是指将两个集合中的所有元素合并成一个新的集合。

为了实现集合的并集运算，我们可以遍历其中一个集合的元素，并将其添加到另一个集合中，同时确保新集合中不包含重复的元素。

下面是一个示例的集合并集运算函数：```cSet unionSet(Set set1, Set set2) {Set resultSet;int resultSetSize = set1.size + set2.size;int resultElements[MAX_SIZE];// 将set1的元素添加到resultSet中for (int i = 0; i < set1.size; i++) {resultElements[i] = set1.elements[i];}// 遍历set2的元素，将不重复的元素添加到resultSet中 for (int i = 0; i < set2.size; i++) {int element = set2.elements[i];int isDuplicate = 0;// 检查element是否已经存在于resultSet中for (int j = 0; j < resultSetSize; j++) {if (element == resultElements[j]) {isDuplicate = 1;break;}}// 如果element不重复，则添加到resultSet中if (!isDuplicate) {resultElements[resultSetSize++] = element;}}initSet(&resultSet, resultSetSize, resultElements);return resultSet;}```四、集合的交集运算集合的交集运算是指找到两个集合中共同存在的元素。

c语言 stdev 函数

c语言 stdev 函数

c语言 stdev 函数stdev函数是C语言中用于计算一组数据的标准差的函数。

标准差是一种衡量数据集合中各个数据离散程度的统计量，它能够反映数据的波动程度和数据点与平均值的偏离程度。

在统计学中，标准差常用于衡量数据的稳定性和可靠性。

在C语言中，stdev函数可以通过以下方式来计算一组数据的标准差：1. 首先，我们需要计算数据的平均值。

可以通过遍历数据集合，将所有数据相加，并除以数据的个数来得到平均值。

2. 接下来，我们需要计算每个数据点与平均值的差值的平方。

可以通过遍历数据集合，将每个数据点与平均值相减，并将差值平方得到差值的平方。

3. 然后，我们需要计算差值的平方的平均值。

可以通过将所有差值的平方相加，并除以数据的个数来得到平均值。

4. 最后，我们需要计算平均值的平方根，即为数据的标准差。

可以通过调用math库中的sqrt函数来计算平均值的平方根。

下面是一个简单的示例代码，展示了如何使用C语言的stdev函数来计算一组数据的标准差：```c#include <stdio.h>#include <math.h>double stdev(double data[], int size) {double sum = 0.0, mean, variance = 0.0;int i;// 计算数据的平均值for(i = 0; i < size; ++i) {sum += data[i];}mean = sum / size;// 计算每个数据点与平均值的差值的平方for(i = 0; i < size; ++i) {variance += pow(data[i] - mean, 2);}// 计算差值的平方的平均值，并返回平均值的平方根 return sqrt(variance / size);}int main() {double data[] = {1.2, 2.3, 3.4, 4.5, 5.6};int size = sizeof(data) / sizeof(data[0]);double result = stdev(data, size);printf("标准差为: %.2f\n", result);return 0;}```在上面的示例代码中，我们定义了一个名为stdev的函数，它接受一个数据数组和数组的大小作为参数，并返回计算得到的标准差。

c语言汇编指令集

c语言汇编指令集

c语言汇编指令集C语言汇编指令集一、引言计算机是由硬件和软件组成的，其中软件部分是由一系列指令组成的。

指令是计算机执行操作的基本单位，而汇编指令集就是这些指令的集合。

C语言是一种高级编程语言，但在底层，C语言也可以通过汇编指令集来直接操作计算机硬件。

本文将介绍C语言汇编指令集的一些常用指令。

二、数据传输指令数据传输指令是用来在寄存器和内存之间传输数据的指令。

常用的数据传输指令有MOV、LDR、STR等。

MOV指令用于将数据从一个寄存器传输到另一个寄存器；LDR指令用于将数据从内存中加载到寄存器；STR指令用于将数据从寄存器存储到内存中。

三、算术运算指令算术运算指令是用于进行算术运算的指令。

常用的算术运算指令有ADD、SUB、MUL、DIV等。

ADD指令用于进行加法运算；SUB 指令用于进行减法运算；MUL指令用于进行乘法运算；DIV指令用于进行除法运算。

四、逻辑运算指令逻辑运算指令是用于进行逻辑运算的指令。

常用的逻辑运算指令有AND、OR、NOT等。

AND指令用于进行按位与运算；OR指令用于进行按位或运算；NOT指令用于进行按位取反运算。

五、条件分支指令条件分支指令用于根据条件进行跳转的指令。

常用的条件分支指令有CMP、BEQ、BNE等。

CMP指令用于比较两个操作数的大小；BEQ指令用于在两个操作数相等时跳转；BNE指令用于在两个操作数不相等时跳转。

六、循环指令循环指令用于实现循环结构的指令。

常用的循环指令有B、BL等。

B指令用于无条件跳转到指定地址；BL指令用于跳转到指定地址并保存返回地址。

七、函数调用指令函数调用指令用于调用函数的指令。

常用的函数调用指令有CALL、RET等。

CALL指令用于调用函数，并将返回地址保存到栈中；RET 指令用于从函数中返回，并将返回地址从栈中弹出。

八、堆栈指令堆栈指令用于操作堆栈的指令。

常用的堆栈指令有PUSH、POP等。

PUSH指令用于将数据压入栈中；POP指令用于从栈中弹出数据。

c语言实现集合的交叉并运算

c语言实现集合的交叉并运算

c语言实现集合的交叉并运算集合是数学中的一个重要概念，它指的是一组具有共同特征的元素的整体。

在数学中，我们经常需要对集合进行交叉并运算，以求得集合之间的关系。

在本文中，我们将使用C语言来实现集合的交叉并运算。

我们需要定义集合的数据结构。

在C语言中，我们可以使用数组来表示集合。

假设我们要操作的集合元素类型为整数，那么我们可以定义一个整型数组来表示集合。

例如，我们可以定义一个名为set1的数组来表示集合A，一个名为set2的数组来表示集合B。

接下来，我们需要编写函数来实现集合的交叉并运算。

首先，我们来实现交集运算。

交集运算指的是找出两个集合中共有的元素。

我们可以通过遍历集合A中的每一个元素，然后与集合B中的每一个元素进行比较，如果找到相同的元素，则将该元素添加到交集的数组中。

具体代码实现如下：```cvoid intersection(int set1[], int set2[], int len1, int len2, int result[], int *len_res) {int i, j;*len_res = 0;for (i = 0; i < len1; i++) {for (j = 0; j < len2; j++) {if (set1[i] == set2[j]) {result[*len_res] = set1[i];(*len_res)++;break;}}}}```上述代码中，我们通过两个嵌套的循环来遍历集合A和集合B，如果找到相同的元素，则将其添加到交集的数组中，并更新交集数组的长度。

接下来，我们来实现并集运算。

并集运算指的是将两个集合中的所有元素合并成一个新的集合。

我们可以通过遍历集合A和集合B，将它们的所有元素依次添加到新的集合中。

具体代码实现如下：```cvoid unionSet(int set1[], int set2[], int len1, int len2, int result[], int *len_res) {int i;*len_res = 0;for (i = 0; i < len1; i++) {result[*len_res] = set1[i];(*len_res)++;}for (i = 0; i < len2; i++) {int j;for (j = 0; j < len1; j++) {if (set2[i] == set1[j]) {break;}}if (j == len1) {result[*len_res] = set2[i];(*len_res)++;}}}```上述代码中，我们首先将集合A中的所有元素添加到新的集合中，然后遍历集合B中的每一个元素，如果该元素不在集合A中，则将其添加到新的集合中。

最新离散数学集合运算C++或C语言实验报告

最新离散数学集合运算C++或C语言实验报告

离散数学实验报告专业班级：12级计算机本部一班姓名：鲍佳珍学号：201212201401016 实验成绩：1．【实验题目】命题逻辑实验四2．【实验目的】掌握用计算机求集合的交、并、差和补运算的方法。

3．【实验内容】编程实现集合的交、并、差和补运算。

4、【实验要求】C或C＋＋语言编程实现5.【算法描述】（1）用数组A，B，C，E表示集合。

假定A={1,3，4，5，6，7，9，10}, B={2，,3，4，7，8，10}, E={1,2，3，4，5，6，7，8，9，10}, 输入数组A，B，E（全集），输入数据时要求检查数据是否重复（集合中的数据要求不重复），要求集合A，B是集合E的子集。

以下每一个运算都要求先将集合C置成空集。

（2）二个集合的交运算：A⋂B={x|x∈A且x∈B}把数组A中元素逐一与数组B中的元素进行比较，将相同的元素放在数组C 中，数组C便是集合A和集合B的交。

C语言算法：for(i=0;i<m;i++)for(j=0;j<n;j++)if(a[i]= =b[j]) c[k++]=a[i];（3）二个集合的并运算：A⋃B={x|x∈A或x∈B}把数组A中各个元素先保存在数组C中。

将数组B中的元素逐一与数组A中的元素进行比较，把不相同的元素添加到数组C中，数组C便是集合A和集合B 的并。

C语言算法：for(i=0;i<m;i++)c[i]=a[i];for(i=0;i<n;i++){for(j=0;j<m;j++)if(b[i]= =c[j]) break;if(j= =m){ c[m+k]=b[i];k++;}}（4）二个集合的差运算：A-B={x|x∈A且x∉B}将数组A中的元素逐一与数组B中的元素进行比较，把数组A与数组B不同的元素保存在数组C中，数组C便是集合A和集合B的差A-B。

C语言算法：for (j=0;j<m;j++){ for (i=0;i<n;i++){ if (A[j]= =B[i]){ C[k]=A[j];k++;break; }if (j= =n){ C[k]=A[i];k++; } }（5）集合的补运算：～A=B-A={x|x∈B且x∉A}将数组E中的元素逐一与数组A中的元素进行比较，把不相同的元素保存到数组C中，数组C便是集合A关于集合E的补集。

集合的并、交运算C语言

集合的并、交运算C语言

集合的并、交运算(C语言) 在C语言中，可以使用逻辑运算符和位运算符来实现集合的并、交运算。

首先，我们需要定义两个布尔类型的数组来表示两个集合。

假设我们有两个集合A和B，它们的元素都是0或1，其中0表示该位置不属于该集合，1表示该位置属于该集合。

我们可以使用以下代码来定义两个集合：int A[10] = {0, 1, 0, 0, 1, 1, 0, 1, 0, 0}; // 集合Aint B[10] = {0, 0, 1, 0, 1, 0, 1, 1, 0, 0}; // 集合B接下来，我们可以使用逻辑运算符来实现集合的并、交运算。

1.并运算并运算即将集合A和集合B的所有元素合并成一个新的集合。

我们可以使用逻辑运算符“|”来实现并运算，代码如下：int C[10]; // 新集合Cfor (int i = 0; i < 10; i++) {C[i] = A[i] | B[i]; // 并运算}在上面的代码中，我们使用循环遍历所有元素，对于每个元素，如果它属于集合A或集合B，则将它赋值给新集合C。

这里使用了逻辑运算符“|”，表示两个集合的并运算。

2.交运算交运算即找出集合A和集合B中共有的元素组成一个新的集合。

我们可以使用逻辑运算符“&”来实现交运算，代码如下：int D[10]; // 新集合Dfor (int i = 0; i < 10; i++) {D[i] = A[i] & B[i]; // 交运算}在上面的代码中，我们同样使用循环遍历所有元素，对于每个元素，如果它既属于集合A又属于集合B，则将它赋值给新集合D。

这里使用了逻辑运算符“&”，表示两个集合的交运算。

需要注意的是，在实际应用中，我们可能需要对数组进行动态分配内存，以适应不同大小的集合。

此外，我们还需要注意数组下标从0开始计数的问题。

集合的交,并,差操作

集合的交,并,差操作

目录序言 (1)中文摘要 (2)1.采用类C语言定义相关数据类型 (3)2.各模块流程图及伪码算法 (4)3.函数的调用关系图 (12)4.调试分析 (13)5.测试结果 (14)6.设计总结 (19)参考文献 (20)致谢 (21)附录（源程序） (22)序言云计算来袭，计算机技术的飞速发展，给我们的生活带来了很大的便利，特别是对于数学运算，一些以前人工计算很麻烦的甚至做不出的问题，计算机在几秒钟就可以算出来。

毫无疑问，计算机技术的应用已是不可阻挡的。

这里我们要做的是集合的简单操作，包括集合的交、并、差。

经过分析，我们使用已经为业界所公认的成熟的稳定的开发工具VC6.0，利用其提供的简单操作，首先在短时间内建立程序原形，然后，对初始原型程序需求分析，编写源程序，不断修正和改进，直到形成满足要求的可行程序。

集合的操作是数据结构中最简单的操作，对集合的学习实践可以帮助我们加深对数据结的掌握程度。

本程序是用单链表的基本操作升华到集合上的操作，来实现集合运算。

中文摘要利用单链表的插入删除操作进一步升华到求两个集合的交、并、差，笛卡尔积等运算。

在Visual C++6.0中实现程序的编译，调试，运行，利用随机数验证并输出这个程序的结果。

通过该题目的设计过程，可以进一步理解和熟练掌握课本中所学的各种数据结构的知识，加深对链表的认识，特别是对于指针、文件的应用，有了更多的认识。

学会如何把学到的知识用于解决实际问题，培养自己的动手能力。

关键词：集合；链表；指针；随机数；文件；1.采用类C语言定义相关数据类型定义单链表typedef struct ListNode{int data; //集合中元素的值struct ListNode *next;//集合的指针域}ListNode,*LinkList;//结点，结构体指针2．各模块流程图及伪码算法建立链表模块LinkList CreateSet(LinkList L) {LinkList p = L,q = NULL;//读取产生的随机数作为集合的元素 FILE *rfile;rfile = fopen("jihe.txt","rb"); if ( rfile == NULL ) { printf("open data.txt error.");return 0;Linklist p,q从文件中读取数据成功randomm()否打开文件失败把生成的随机数读取到文件中fread （）是结束}int rs = 0;int rra[20] = {0};rs = fread(rra, sizeof(int),20,rfile);for ( int j = 0 ; j < rs; j++){q = NULL;q = (LinkList)malloc(sizeof(ListNode));q->next=NULL;q->data = rra[j]; //读取元素值p->next = q;p = p->next;}//forfclose(rfile);return L;}计算集合并的函数模块//求并集LinkList Union(LinkList A,LinkList B,LinkList C) {LinkList pa, pb, pc,tail; pa = A->next; pb = B->next; tail = C; while(pa && pb) { if((pa->data) <= (pb->data)){pc = (LinkList)malloc(sizeof(ListNode)); LinkList pa, pb, pc,tail;pa!=null &&pb!=nullpa->data<=pb->datapc->data = pa->datapc->data = pb->data结束否否是是pc->data = pa->data;pc->next=tail->next;tail->next = pc;tail = pc;pc = pc->next;pa = pa->next;}//ifelse{pc = (LinkList)malloc(sizeof(ListNode));pc->data = pb->data;pc->next=tail->next;tail->next = pc;tail = pc;pc = pc->next;pb = pb->next;}//else}if(pa == NULL){pc = pb;tail->next = pc;tail = pc;}//ifelse{pc = pa;tail->next = pc;tail = pc;}//else}//whilereturn(C);}计算集合交的函数模块//求交集LinkList Intersection(LinkList A,LinkList B,LinkList L) {ListNode *pa, *pb, *pc,*tail; tail = L; pa = A->next; pb = B->next; while (pa && pb) { if (pa->data < pb->data) {pa = pa->next;LinkList pa, pb, pc,tail;pa!=null &&pb!=nullpa->data==pb->datapc->data = pa->data释放pa,pb结束否否是是}//ifelse if (pa->data > pb->data){pb = pb->next;}//else ifelse{pc = (LinkList)malloc(sizeof(ListNode));pc->data = pa->data;pc->next=tail->next;tail->next = pc;tail = pc;pc = pc->next;pa = pa->next;pb = pb->next;}//else}//whilereturn L;}计算集合1与集合2的差 的函数模块//求差集LinkList Difference(LinkList A,LinkList B,LinkList C) {LinkList pa, pb, pc; pa = A->next; pb = B->next; pc = A;while(pa && pb) { if (pa->data != pb->data) {pc->next = pa;LinkList pa, pb, pc,tail;pa!=null &&pb!=nullpa->data ！=pb->datapc->data = pa->data释放pa,pb结束否否是是pc = pa;pa = pa->next;}//ifelse{pa = pa->next;pb = pb->next;}//else}//whilereturn A;}3.函数的调用关系图main()menu_select()CreateSet CreateSet2 Difference Union Intersection PrintSet4.调试分析a.调试中遇到的问题及对问题的解决方法调试中遇到的问题中主要是内存泄露问题，指针何时分配空间何时释放空间没有搞清楚，还有随机数产生完成后不知道怎么读入到链表中，对于这些问题，我上网查阅相关的资料，来进一步的确定问题的本质，从而解决问题的每一步。

集合的特征函数运算

集合的特征函数运算

用集合的特征函数实现集合间的运算六、C语言源代码：/*--------------------------------------------------------------------------------用集合的特征函数实现集合间的运算-----------------------------------------编译环境：VS 2013--------------------------------------------------------------------------------------*/#define_CRT_SECURE_NO_WARNINGS//用于取消VS 2013对printf、scanf等函数的警告#include<stdio.h>#include<stdlib.h>//定义集合数据类型用于存放集合typedef struct{char *data;int count;}Assemble;//定义特征函数数据类型用于存放集合的特征函数typedef struct{int *data;int count;}Eigenfunction;void initAssemble(Assemble *A, char assemble[]);//初始化集合，并存储集合元素void creatEigenfunction(Eigenfunction *A, char assemble[]);//建立集合的特征函数并存储void showEigenfunction(Eigenfunction *A);//输出集合的特征函数void intersection(Eigenfunction*Intersection_AB, Eigenfunction*A, Eigenfunction *B);//利用集合的特征函数进行交运算void Union(Eigenfunction *Union_AB, Eigenfunction *A, Eigenfunction *B);//利用集合的特征函数进行并运算void showAssemble(Eigenfunction *A);//输出集合元素Assemble U;//把全集U定义为全局变量int main(){char temp_U[50], temp_A[50], temp_B[50];Eigenfunction A, B, Intersection_AB, Union_AB;system("color 5B");//设置程序框的背景色和前景色printf("请输入全集U：");gets(temp_U);initAssemble(&U, temp_U);printf("\n请输入集合A：");gets(temp_A);creatEigenfunction(&A, temp_A);printf("\n请输入集合B：");gets(temp_B);creatEigenfunction(&B, temp_B);printf("\n集合A的特征函数：\n");showEigenfunction(&A);printf("集合B的特征函数：\n");showEigenfunction(&B);intersection(&Intersection_AB, &A, &B);printf("\n集合A交B的特征函数：\n");showEigenfunction(&Intersection_AB);Union(&Union_AB, &A, &B);printf("集合A并B的特征函数：\n");showEigenfunction(&Union_AB);printf("\n集合A交B的元素：");showAssemble(&Intersection_AB);printf("集合A并B的元素：");showAssemble(&Union_AB);return 0;}void initAssemble(Assemble *A, char assemble[]){int i = 0, j = 0, count = 0;while (assemble[i] != '\0'){if (('0' <= assemble[i] && assemble[i] <= '9') || ('A' <= assemble[i] && assemble[i] <= 'Z') || ('a' <= assemble[i] && assemble[i] <= 'z')){count++;i++;}elsei++;}A->data = (char *)malloc(sizeof(char)*count);if (A->data == NULL){puts("动态内存分配失败！");exit(-1);i = 0;while (assemble[i] != '\0'){if (('0' <= assemble[i] && assemble[i] <= '9') || ('A' <= assemble[i] && assemble[i] <= 'Z') || ('a' <= assemble[i] && assemble[i] <= 'z')){A->data[j] = assemble[i];j++;i++;}elsei++;}A->count = count;}void creatEigenfunction(Eigenfunction *A, char assemble[]){int i, j;Assemble temp_A;initAssemble(&temp_A, assemble);A->data = (int *)malloc(sizeof(int)*U.count);if (A->data == NULL){puts("动态内存分配失败！");exit(-1);}A->count = U.count;for (i = 0; i < U.count; i++){for (j = 0; j < U.count; j++){if (temp_A.data[j] == U.data[i]){A->data[i] = 1;break;}elseA->data[i] = 0;}free(temp_A.data);}void showEigenfunction(Eigenfunction *A){int i;for (i = 0; i < A->count; i++)printf("X（%c）= %d\t", U.data[i], A->data[i]);printf("\n");}void intersection(Eigenfunction*Intersection_AB, Eigenfunction*A, Eigenfunction *B){int i;Intersection_AB->data = (int *)malloc(sizeof(int)*U.count);if (Intersection_AB->data == NULL){puts("动态内存分配失败！");exit(-1);}Intersection_AB->count = U.count;for (i = 0; i < U.count; i++)if (A->data[i] == 1 && B->data[i] == 1)Intersection_AB->data[i] = 1;elseIntersection_AB->data[i] = 0;}void Union(Eigenfunction *Union_AB, Eigenfunction *A, Eigenfunction *B){int i;Union_AB->data = (int *)malloc(sizeof(int)*U.count);if (Union_AB->data == NULL){puts("动态内存分配失败！");exit(-1);}Union_AB->count = U.count;for (i = 0; i < U.count; i++)if (A->data[i] == 0 && B->data[i] == 0) Union_AB->data[i] = 0;elseUnion_AB->data[i] = 1;}void showAssemble(Eigenfunction *A){int i;for (i = 0; i < A->count; i++)if (A->data[i] == 1)printf("%4c", U.data[i]);printf("\n");}。

C语言位操作运算详解

C语言位操作运算详解

位运算程序中的所有数在计算机内存中都是以二进制的形式储存的。

位本文会以C语言的交互环境来做代码演示常见的二进制位的变换操作and运算 &•判断奇偶数对于除0以外的任意数x，使用x&1==1作为逻辑判断即可if (x&1==1){}•判断某个二进制位是否为1比如第7位, 0x40转到二进制是0100 0000,代表第7位是1.if (n&0x40){//TODO:添加你要处理的代码}•字节读取(x >> 0) & 0x000000ff /* 获取第0个字节*/(x >> 8) & 0x000000ff /* 获取第1个字节*/(x >> 16) & 0x000000ff /* 获取第2个字节*/(x >> 24) & 0x000000ff /* 获取第3个字节*/•判断一个数是不是 22 的指数bool isPowerOfTwo(int n) {if (n <= 0) return false;return (n & (n - 1)) == 0;}•取余//得到余数int Yu(int num,int n){int i = 1 << n;return num&(i-1);}•指定二进制位数截取比如说16位二进制数A：1001 1001 1001 1000，如果来你想获A 的哪一位的值,就把数字B：0000 0000 0000 0000的那一位设置为1.比如说我想获得A的第三位就把B的第三位数字设置为1，则B为0000 0000 0000 0100，设置完之后再把A、B求与，其结果若为0，说明A的第三位为0，其结果为1，说明A的第三位为1.同理：若要获得A的第五位，就把B设置为0000 0000 0001 0000，之后再求与。

通常在我们的程序中，数字B被称为掩码，其含义是专门用来测试某一位是否为0的数值。

C语言实现集合的交,并,差

C语言实现集合的交,并,差
DelFirst(lsb,node);Append(lsc,node);
}
return OK;
}
Status IntersectionSets(LinkSet &lsa,LinkSet &lsb, LinkSet &lsc)...{
//已知集合ls1,ls2的元素按值非递减排列
//将集合ls1，ls2的交集到ls3
ls.tail = (Link) malloc( sizeof(Link));
if(!ls.head || !ls.tail) exit(OVERFLOW); //如果分配失败
ls.head->next = ls.tail->next = NULL; //头、尾指针为空
ls.len = 0; //长度为0
int result = Compare(pa,pb);
if( result<0) ...{
DelFirst(lsa,node);pa = NextPos(ha);
}else if(result>0)...{
DelFirst(lsb,node); pb = NextPos(hb);
}else...{
}
return OK;
}
Status DifferenceSets(LinkSet &lsa,LinkSet &lsb, LinkSet &lsc)...{
//已知集合ls1,ls2的元素按值非递减排列
//ls3 = ls1 - ls2
if( !InitSe h->next;
}
printf(" ] ");
return OK;
}

c语言集合的交并运算

c语言集合的交并运算

c语言集合的交并运算C语言是一种广泛应用的编程语言，它提供了丰富的数据结构和操作方法，其中集合的交并运算是C语言中常用的操作之一。

本文将围绕集合的交并运算展开，介绍相关概念、操作方法和实际应用。

一、集合的基本概念在C语言中，集合可以看作是一组具有相同类型的元素的无序集合。

集合中的元素不重复，每个元素都具有唯一的标识。

集合的交运算和并运算是两种常用的操作，下面将详细介绍这两种操作的含义和实现方法。

二、集合的交运算集合的交运算指的是求两个集合中共同存在的元素构成的新集合。

假设集合A和集合B分别为{1, 2, 3, 4}和{3, 4, 5, 6}，则它们的交集为{3, 4}。

在C语言中，可以使用循环和条件判断来实现集合的交运算。

具体实现方法如下：1. 定义两个集合A和B，并初始化它们的元素。

2. 创建一个新的集合C，用于存放交集的元素。

3. 使用循环遍历集合A的每个元素，对于每个元素，判断它是否同时存在于集合B中。

4. 如果存在，则将该元素添加到集合C中。

5. 最后，集合C中存放的就是A和B的交集。

三、集合的并运算集合的并运算指的是将两个集合中的所有元素合并成一个新集合。

假设集合A和集合B分别为{1, 2, 3, 4}和{3, 4, 5, 6}，则它们的并集为{1, 2, 3, 4, 5, 6}。

在C语言中，可以使用循环和条件判断来实现集合的并运算。

具体实现方法如下：1. 定义两个集合A和B，并初始化它们的元素。

2. 创建一个新的集合C，用于存放并集的元素。

3. 遍历集合A的每个元素，将它们依次添加到集合C中。

4. 遍历集合B的每个元素，对于每个元素，判断它是否已经存在于集合C中。

5. 如果不存在，则将该元素添加到集合C中。

6. 最后，集合C中存放的就是A和B的并集。

四、集合运算的应用集合的交并运算在实际应用中具有广泛的用途。

以下列举几个常见的应用场景：1. 数据去重：当需要对一组数据进行去重操作时，可以将这组数据看作是一个集合，通过求其并集得到去重后的结果。

数据结构（C语言版）习题及答案第二章

数据结构（C语言版）习题及答案第二章

数据结构（C语⾔版）习题及答案第⼆章习题2.1选择题1、线性表的顺序存储结构是⼀种（A）的存储结构，线性表的链式存储结构是⼀种（B）的存储结构。

A、随机存取B、顺序存取C、索引存取D、散列存取2、对于⼀个线性，既要求能够进⾏较快的插⼊和删除，⼜要求存储结构能够反映数据元素之间的逻辑关系，则应该选择（B）。

A、顺序存储⽅式B、链式存储⽅式C、散列存储⽅式D、索引存储⽅式3、已知，L是⼀个不带头结点的单链表，p指向其中的⼀个结点，选择合适的语句实现在p结点的后⾯插⼊s结点的操作（B）。

A、p->next=s ; s->next=p->next ;B、s->next=p->next ; p->next=s ;C、p->next=s ; s->next=p ;D、s->next=p ; p->next=s ;4、单链表中各结点之间的地址（ C D）。

A、必须连续B、部分地址必须连续C、不⼀定连续D、连续与否都可以5、在⼀个长度为n的顺序表中向第i个元素（0A、n-iB、n-i+1C、n-i-1D、i2.2填空题1、顺序存储的长度为n的线性表，在任何位置上插⼊和删除操作的时间复杂度基本上都⼀样。

插⼊⼀个元素⼤约移动表中的（n/2）个元素，删除⼀个元素时⼤约移动表中的（(n-1)/2）个元素。

2、在线性表的顺序存储⽅式中，元素之间的逻辑关系是通过（物理顺序）来体现的；在链式存储⽅式，元素之间的逻辑关系是通过（指针）体现的。

3、对于⼀个长度为n的单链表，在已知的p结点后⾯插⼊⼀个新结点的时间复杂度为（o(1)），在p结点之前插⼊⼀个新结点的时间复杂度为（o(n)），在给定值为e的结点之后插⼊⼀个新结点的时间复杂度为（o(n)）。

4、在双向链表中，每个结点包含两个指针域，⼀个指向（前驱）结点，另⼀个指向（后继）结点。

5、对于循环链表来讲，逐个访问各个结点的结束判断条件是（设P为指向结点的指针，L为链表的头指针，则p->next= =L）。

  1. 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

C语言实现集合的交,并,
差
公司内部编号：（GOOD-TMMT-MMUT-UUPTY-UUYY-DTTI-
【问题描述】
编制一个能演示执行集合的并、交和差运算的程序【基本要求】
（1）集合的元素限定为小写字母字符[ 'a'......'z' ]
（2 ）演示程序以用户和计算机对话的方式执行
【测试数据】
【实现提示】
以有序链表表示集合
【代码过程】
1。

先定义集合的数据类型
.{
ElemType data;
LNode *next;
}*Link, *Position;
typedef struct...{
Link head,tail;
int len;
}LinkSet;
.{
.{
.{
if(h1->data < (link->data) && h2->data > (link->data) ) .{ .{
.{
.{
pre = h; h=h->next; j++;
}
if(j==0) return NULL;
return pre;
}
Status PrintSets(LinkSet &ls)...{
.{
printf("%c ",h->data);
h = h->next;
}
printf(" ] ");
return OK;
}
Position GetHead(LinkSet &ls)...{
.{
.{
.{
.{
.{
.{.{
.{
int result = Compare(pa,pb); .{
DelFirst(lsa,node);Append(lsc,node); pa =
NextPos(ha); .{ .{
DelFirst(lsb,node); pb = NextPos(hb);.{
DelFirst(lsa,node);Append(lsc,node);
}
while(!Empty(lsb))...{
DelFirst(lsb,node);Append(lsc,node);
}
return OK;
}
Status IntersectionSets(LinkSet &lsa,LinkSet &lsb, LinkSet &lsc)...{ .{
int result = Compare(pa,pb);
if( result<0) ...{
DelFirst(lsa,node);pa = NextPos(ha);
}else if(result>0)...{
DelFirst(lsb,node); pb = NextPos(hb);
}else...{
DelFirst(lsb,node); Append(lsc,node);pb = NextPos(hb);
DelFirst(lsa,node);pa = NextPos(ha);
}
}
while(!Empty(lsa))...{
DelFirst(lsa,node);Append(lsc,node);
}
return OK;
}
Status DifferenceSets(LinkSet &lsa,LinkSet &lsb, LinkSet &lsc)...{
.{
int result = Compare(pa,pb);
if( result<0) ...{
DelFirst(lsa,node);Append(lsc,node);pa = NextPos(ha); }else if(result>0)...{
DelFirst(lsb,node); pb = NextPos(hb);
}else...{
DelFirst(lsa,node); pa = NextPos(ha);
DelFirst(lsb,node); pb = NextPos(hb);
}
}
return OK;
}
Status CopySets(LinkSet lsa, LinkSet lsb)...{
.{
Link node;
CreateNode(node,la->data);
lb=node;
++;
la = la->next;
lb = lb->next;
}
= lb;
return OK;
}
.{
printf("************************************************************** ************** " );
printf("*MakeSet1-1 MakeSet1-2 Union-u Intersection-i Difference-d Quit-q * " );
printf("************************************************************** ************** " );
}
void main()
...{
LinkSet set1,set2,set3,seta,setb;
InitSets(set1),InitSets(set2); .{
Initialization();
printf("集合Set1:");
PrintSets(set1); .{
case '1': //集合set1 赋值
printf("请输入集合Set1的内容：");
fflush(stdin);
gets(setsContent);
InitSets(set1);
SetSets(set1,setsContent);
break;
case '2': //集合set1 赋值
printf("请输入集合Set1的内容：");
fflush(stdin);
gets(setsContent);
SetSets(set2,setsContent);
break;
case 'u':
case 'U': //求并
InitSets(set3);
CopySets(set1,seta); //因为求并的算法是添加一个节点，删除set1,set2中对应的节点，
CopySets(set2,setb); //所以要复制一份
UnionSets(seta,setb,set3); //下同
printf("set1 U set2=: ");
PrintSets(set3);
fflush(stdin);
getchar();
break;
case 'i':
case 'I': //求交
InitSets(set3);
CopySets(set1,seta);
CopySets(set2,setb);
IntersectionSets(seta,setb,set3);
printf("set1 交 set2=: ");
fflush(stdin);
getchar();
break;
case 'd':
case 'D': //求差 InitSets(set3);
CopySets(set1,seta);
CopySets(set2,setb);
DifferenceSets(seta,setb,set3);
printf("set1 - set2=: ");
PrintSets(set3);
fflush(stdin);
getchar();
break;
case 'q':
case 'Q':
exit(0);
break;
}
system("cls"); //清屏
}
} //~。

相关文档
最新文档