精华内容
下载资源
问答
  • 集合(用单链表表示)的运算: 问题描述:该算法的设计,要求运行结果如下所示: (包含三种排序) 集合的运算如下: 原 集 合A: c a e h 原 集 合B: f h b g d a 有序集合A: a c e h 有序集合B: a b d f g...

    求集合(用单链表表示)的并、交和差运算:
    问题描述:该算法的设计,要求运行结果如下所示:
    (包含三种排序)

    集合的运算如下:
    原 集 合A: c a e h
    原 集 合B: f h b g d a
    有序集合A: a c e h
    有序集合B: a b d f g h
    集合的并C: a b c d e f g h
    集合的交C: a h
    集合的差C: c e

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #define OK 1
    
    typedef char elemtype;
    typedef int  Status;
    
    typedef struct LNode {
    	elemtype data;
    	struct LNode *next;
    } LNode,*LinkList;
    
    Status InitList(LinkList &L) {
    	L=(LinkList)malloc(sizeof(LNode));
    	if(!L)  exit(-1);
    	L->next=NULL;
    	return OK;
    }
    
    Status ListInsert_L(LinkList &L,int i,elemtype e) {
    	LinkList p=L,q;
    	int j=0;
    	for(; p&&j<i-1; j++)
    		p=p->next;
    	if(p&&j>i-1)  return -1;
    	q=(LinkList)malloc(sizeof(LNode));
    	q->data=e;
    	q->next=p->next;
    	p->next=q;
    }
    
    Status ListPritnt_L(LinkList &L) {
    	LinkList p=L;
    	for(p=p->next; p; p=p->next) {
    		printf("%c ",p->data);
    	}
    	printf("\n");
    }
    
    Status ListLength(LinkList &L) {
    	int i=0;
    	LinkList p=L->next;
    	while(p) {
    		p=p->next;
    		i++;
    	}
    	return i;
    }
    
    Status ListSort_L1(LinkList &L) { //交换结点的冒泡排序
    	LinkList p,q,p_prior;
    	int i,j,n;
    	n=ListLength(L);
    	for(i=1; i<n; i++) {
    		p=L->next;
    		q=p->next;
    		p_prior=L;
    		for(j=0; j<n-i; j++) {
    			if((p->data)>(q->data)) {
    				p_prior->next=q;
    				p->next=q->next;
    				q->next=p;
    				//交换后的更新结点情况和没交换时不同
    				p_prior=q;
    				q=p->next;
    			} else {
    				p_prior=p;
    				p=q;
    				q=q->next;
    			}
    		}
    	}
    	p=q=p_prior=NULL;
    }
    
    Status ListSort_L2(LinkList &L) { //直接交换内部元素
    	LinkList p,q;
    	elemtype temp;
    	int i,j,n;
    	n=ListLength(L);
    	for(i=1; i<n; i++)
    		for(j=0,p=L->next,q=p->next; j<n-i; p=q,q=q->next,j++) {
    			if((p->data)>(q->data)) {
    				temp=p->data;
    				p->data=q->data;
    				q->data=temp;
    			}
    		}
    	p=q=NULL;
    }
    
    void BubbleSort(struct LNode * head) { 
    	//https://www.cnblogs.com/darkchii/p/7302412.html
    	struct LNode * p, * q, * tail;
    
    	tail = NULL;
    
    	while((head->next->next) != tail) {
    		p = head;
    		q = head->next;
    		while(q->next != tail) {
    			if((q->data) > (q->next->data)) {
    				p->next = q->next;
    				q->next = q->next->next;
    				p->next->next = q;
    				q = p->next;
    			}
    			q = q->next;
    			p = p->next;
    		}
    		tail = q;
    	}
    }
    
    LinkList ListMerge_L(LinkList &L1,LinkList &L2) { //L1,L2有序情况的合并
    	LinkList p=L1->next,q=L2->next;
    	LinkList L3;
    	int i=1;
    	InitList(L3);
    	while(p&&q) {
    		if(p->data<q->data) {
    			ListInsert_L(L3,i++,p->data);
    			p=p->next;
    		} else if(p->data==q->data) {
    			ListInsert_L(L3,i++,p->data);
    			p=p->next;
    			q=q->next;
    		} else {
    			ListInsert_L(L3,i++,q->data);
    			q=q->next;
    		}
    	}
    	while(p) {
    		ListInsert_L(L3,i++,p->data);
    		p=p->next;
    	}
    	while(q) {
    		ListInsert_L(L3,i++,q->data);
    		q=q->next;
    	}
    	return L3;
    }
    
    LinkList ListIntersect_L(LinkList &L1,LinkList &L2) {
    	LinkList p=L1->next,q=L2->next;
    	LinkList L;
    	int i=1,flag=0;
    	InitList(L);
    	while(p) {
    		while(q) {
    			if(p->data==q->data) {
    				flag=1;
    				break;
    			}
    			q=q->next;
    		}
    		if(flag) {
    		ListInsert_L(L,i++,q->data);
    		}
    		p=p->next;
    		q=L2->next;
    		flag=0;
    	}
    
        return L;
    }
    
    
    LinkList ListDifferent_L(LinkList &L1,LinkList &L2) {//就是把交运算改一下 
    	LinkList p=L1->next,q=L2->next;
    	LinkList L;
    	int i=1,flag=1;
    	InitList(L);
    	while(p) {
    		while(q){
    			if(p->data==q->data) {
    				flag=0;
    				break;
    			}
    			q=q->next;
    		}
    		if(flag) {
    		ListInsert_L(L,i++,p->data);
    		}
    		p=p->next;
    		q=L2->next;
    		flag=1;
    	}
        return L;
    }
    int main() {
    	elemtype A[10]= {'c','a','e','h'};
    	elemtype B[10]= {'f','h','b','g','d','a'};
    	int i;
    	LinkList head1,head2,head3,head4,head5;
    	InitList(head1);
    	InitList(head2);
    
    	for(i=0; A[i]; i++) {
    		ListInsert_L(head1,i+1,A[i]);
    	}
    	printf("原 集 合A:");
    	ListPritnt_L(head1);
    
    	for(i=0; B[i]; i++) {
    		ListInsert_L(head2,i+1,B[i]);
    	}
    	printf("原 集 合B:");
    	ListPritnt_L(head2);
    
    	ListSort_L1(head1);
    	ListSort_L2(head2);
    	printf("有序集合A:");
    	ListPritnt_L(head1);
    	printf("有序集合B:");
    	ListPritnt_L(head2);
    
    	head3=ListMerge_L(head1,head2);
    	printf("集合的并C:");
    	ListPritnt_L(head3);
    
    	head4=ListIntersect_L(head1,head2);
    	printf("集合的交C:");
    	ListPritnt_L(head4);
    	
    	head5=ListDifferent_L(head1,head2);
    	printf("集合的差C:");
    	ListPritnt_L(head5);	
    }
    
    展开全文
  • 数据结构–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

    展开全文
  • 实现运算时,分别把代码写成函数的形式,即实现运算的函数,实现运算的函数,实现运算的函数,在主函数中分别调用三个函数。 使用菜单形式对应各个操作,应允许用户反复查看结果,想结束程序时,...

    姗姗来迟的链表。

    老规矩,上效果图:
    在这里插入图片描述
    要求:
    从程序完善性上考虑,集合元素输入时,要有检查元素重复的功能,每个集合中不允许有重复的元素。集合可以用数组也可以用链表存储。
    实现交、并、差运算时,分别把代码写成函数的形式,即实现交运算的函数,实现并运算的函数,实现差运算的函数,在主函数中分别调用三个函数。
    使用菜单形式对应各个操作,应允许用户反复查看结果,想结束程序时,输入负数结束,使其编成一个完整的小软件。菜单参考示例如下:
    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>
    #include <stdlib.h>
    #define ERROR  -1 
    //创建结构体 
    typedef struct Node{
     int data;    
     struct Node *next;   //指向下一个指针 
    }Node,*Link;   //typedef 起别名 ,结尾有分号 
    /*     //上面的同这个 
    struct node{
     int data;    
     struct node *next;   //指向下一个指针 
    };    
    typedef struct Node Node;  //为 struct Node类型起别名Node
    typedef struct Node *Link;  //为struct Node 指针类型起别名Link 
    */
    
    //菜单 
    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");
    }
    
    //创建空链表 
    Link list(Link l){
     Link head=(Link)malloc(sizeof(Node));         //创建头节点 
     if(head==NULL){          //如果头节点未空 
      return 0;
     }
     l=head;
     l->next =NULL;         //把头节点指针置空,就像把一条直线变成射线 
     return l;
    }
    
    //录入数据,头插法,新的数据指针指向头节点的指针 
    Link input(Link l,int n){
     Link p;
     int i;
     printf("请输入元素\n");
     for(i=1;i<=n;i++){
      p=(Link)malloc(sizeof(Node));       //开辟新节点,及分配空间 
      if(p!=NULL){              //节点开辟成功  
       scanf("%d",&p->data);   
       p->next=l->next;     //头插 
       l->next=p;
      }else{
       return 0;
      }
     }
     printf("集合输入完成\n");
     return l;
    } 
    
    //输出,遍历 
    Link output(Link l){
     Link p;
     if(l->next==NULL){
      printf("该链表是空链表\n");
     }else{
      for(p=l->next;p!=NULL;p=p->next){
       printf("%d\t",p->data);
      }
     // printf("\n");
     }
    }
    
    //清空链表
    void clear(Link l){
     Link p,q;
     p=l->next;
     if(!p){
      return;
     }
     while(p!=NULL){
      q=p;
      p=p->next;
      free(q);     //释放节点空间 
     }
     l->next=NULL;       //将l链表的next指针域置空 
     printf("This part is over\n");
    } 
    
    //并集 先清空c,再用a与c比较,b与c比较,将没有的数据全插入
    Link hand(Link La,Link Lb,Link Lc){
     Link r,s,p,q;
     p=La->next;
     while (p){
      q=(Link)malloc(sizeof(Node));       //生成新的节点 
      q->data=p->data;
      q->next=Lc->next;             //1.将c的指针赋给q 
      Lc->next=q;                   //2.再使c的指针指向q( 头插法 )
      p=p->next;                    //用p遍历a链表 
     }
     /*
     //方法2:尾插法插a 
     p=La->next; 
     r=Lc;          //将头指针地址赋给r,不能直接用Lc操作,防止丢失头指针地址  
     while(p!=NULL){
      s=(Link)malloc(sizeof(Node));
      s=p;
      r->next=s;     //将r的指针指向s 
      r=s;           //再将s的地址赋给r 
     }
     r->next=NULL;
     */
     p=Lb->next;
     while(p){
      q=La->next;
      while(q && (q->data!=p->data)){    //查重 
       q=q->next;
      }
      if(!q){          //若遍历完c都没有重复元素 
       r=(Link)malloc(sizeof(Node));
       r->data=p->data;  
       r->next=Lc->next;  
       Lc->next=r;  
      }
      p=p->next;
     } 
    }
    
    //交集,各步骤类似于并集 
    void combine(Link La,Link Lb,Link Ld){
     Link p,q,r;
     p=La->next;
     while(p!=NULL){
      q=Lb->next;
      while(q!=NULL){
       if(p->data==q->data){       //判断a表和b表元素是否相等,若相等,这赋值给c表 
        r=(Link)malloc(sizeof(Node));
        r=p;
        r->next=Ld->next;
        Ld->next=r;
       }
       q=q->next;
      }
      p=p->next;  
     }
    }
    
    //差集
    Link reduce(Link La,Link Lb,Link Le){
     Link p,q,r;
     p=La->next;
     while(p){
      q=Lb->next;
      while(q && (q->data!=p->data)){
       q=q->next;
      }
      if (!q){
       r=(Link)malloc(sizeof(Node));
       r->data=p->data;
       r->next=Le->next;
       Le->next=r;
      }
      p=p->next;
     }
    }
    
    int main(){
     int x,y,i,choice;
     Link La,Lb,Lc,Ld,Le;
     //初始化
     La=list(La);
     Lb=list(Lb);
     Lc=list(Lc);
     Ld=list(Ld);
     Le=list(Le); 
     //菜单 
     while(1){
      show();
      printf("请输出要选择的功能:\n");
      scanf("%d",&choice);
      if(choice<0){
       clear(La);
       clear(Lb);
       clear(Lc);
       clear(Ld);
       clear(Le);
       printf("已退出\n");
       return 0;
      }
      switch(choice){
       case 1:
        printf("请输入A集合中元素个数\n");
        scanf("%d",&x);
        printf("请输入B集合中元素个数\n");
        scanf("%d",&y);
        input(La,x);
        input(Lb,y);
        printf("A={"); 
        output(La);
        printf("}");
        printf("B={"); 
        output(Lb);
        printf("}");
        printf("请按回车继续!\n");
        getchar();
        getchar();
        system("cls");
        break;
       case 2:
        hand(La,Lb,Lc);
        printf("A并B={");
        output(Lc); 
        printf("}");
        printf("请按回车继续!\n");
        getchar();
        getchar();
        system("cls");
        break;
       case 3:
        combine(La,Lb,Ld);
        printf("A交B={");
        output(Lc); 
        printf("}");
        printf("请按回车继续!\n");
        getchar();
        getchar();
        system("cls");
        break;
       case 4:
        reduce(La,Lb,Le);
        printf("A-B={");
        output(Lc); 
        printf("}");
        printf("请按回车继续!\n");
        getchar();
        getchar();
        system("cls");
        break;
       default:
        printf("输入有误!\n");
        printf("请按回车继续!\n");
        getchar();
        getchar();
        system("cls");
        break;
      }
     }
     return 0;
    }
    
    

    小结
    一不小心就鸽了这么旧,哈哈哈。
    用数组实现集合的(交,并,差)链接
    https://blog.csdn.net/e_t_e_r_n_i_t_y/article/details/108800898
    都是我自己写的,感兴趣的可以看一下!

    展开全文
  • if(c.elem[i]==c.elem[i+1])//删除集合中相同的元素 continue; else printf("%d ",c.elem[i]); } printf("\n"); } //求a和b的并集 int unionList(Sqlist &a,Sqlist &b,Sqlist &c) { int i=0,j=0,k=0; c.length=a....

    //c语言
    #include<stdio.h>
    #include<malloc.h>
    #define LIST_INIT_SIZE 100 //线性表存储空间的初始分配量
    #define  LISTINCREASE  10 // 线性表存储空间的分配增量
    typedef int ElemType;
    typedef int Status;
    typedef struct
    {
      ElemType *elem;/* 存储空间的首地址 */
      int length; /* 当前长度 */
      int listsize;/* 当前分配的存储空间 */
    }Sqlist;
    
    
    
    
    //初始化线性表
    Status InitList_Sq(Sqlist &L){
      L.elem=(ElemType *)malloc(LIST_INIT_SIZE* sizeof(ElemType));
      if(!L.elem) return -1;//存储分配失败
      L.length=0;//设置长度
      L.listsize=LIST_INIT_SIZE;//设置已经分配的空间
      return 1;
    }
    //线性表中元素排序(冒泡排序)
    void  sort_Sq(Sqlist &L)
    {
      int i,j,temp;
      int exchange;
      for(i=0;i<L.length-1;i++)
      {
        exchange=0;
    for(j=L.length-2;j>=i;j--)
    {
    if(L.elem[j+1]<L.elem[j])
    {
    temp=L.elem[j+1];
    L.elem[j+1]=L.elem[j];
    L.elem[j]=temp;
    exchange=1;
    } 
    }
    if(!exchange) return;
      }
    
    
    }
    //显示各种操作后的结果
    void displaylist_Sq(Sqlist &c)
    {
    if(c.length==0) //判断操作后的集合是否为空
    printf("该操作后的集合为空!\n");
    for(int i=0;i<c.length;i++)
    {
    if(c.elem[i]==c.elem[i+1])//删除集合中相同的元素
    continue;
    else
    printf("%d ",c.elem[i]);
    }
    printf("\n");
    }
    
    
    //求a和b的并集
    int unionList(Sqlist &a,Sqlist &b,Sqlist &c)
    {
        int i=0,j=0,k=0;
    c.length=a.length+b.length;
        c.elem=(ElemType *)malloc(c.length * sizeof(ElemType));
       if(!c.elem) return -1;
       while(i<a.length && j<b.length)
       {
         if(a.elem[i]<b.elem[j]) 
    c.elem[k++]=a.elem[i++];
    else 
    if(a.elem[i]>b.elem[j])
      c.elem[k++]=b.elem[j++];
    else 
    {
      c.elem[k++]=a.elem[i++];
      j++;
    }
    
       }
      
    while(i<a.length) 
    c.elem[k++]=a.elem[i++];
    while(j<b.length)
    c.elem[k++]=b.elem[j++];
    c.length=k;
    displaylist_Sq(c);
    
    
    }
    //求a和b的交集
    void mixdlist_Sq(Sqlist &a,Sqlist &b,Sqlist &c)
    {
        int i=0,j=0,k=0;
    c.length=a.length>b.length?a.length:b.length;
    while(i<a.length  && j<b.length)
    {
         if(a.elem[i]<b.elem[j]) i++;
     else if(a.elem[i]>b.elem[j])  
     j++;
    else {
     c.elem[k++]=a.elem[i++];
     j++;
     }
    
    
    }
    c.length=k;
       displaylist_Sq(c);
    }
    //求a和b的差集
    void difrentlist_Sq(Sqlist &a,Sqlist &b,Sqlist &c)
    {
         int i=0,j=0,k=0;
    c.length=a.length>b.length?a.length:b.length;
    while(i<a.length  && j<b.length)
    {
    if(a.elem[i]<b.elem[j]) c.elem[k++]=a.elem[i++];
    else 
    if(a.elem[i]>b.elem[j]) j++;
    else {i++;j++;}
    }
    while(i<a.length) c.elem[k++]=a.elem[i++];
    c.length=k;
           displaylist_Sq(c);
    }
    /*用在分配c集合的方法来进行求交叉并集*/
    
    
    int main()   
    {
    Sqlist  a,b,c;
     int i,j;
    InitList_Sq(a);
    InitList_Sq(b);    //输入集合a与b的元素
    printf("请输入a集合的长度:\n");
    scanf("%d",&a.length);
    printf("<元素>:\n");
    for(i=0;i<a.length;i++)
    scanf("%d",&a.elem[i]);
    printf("排序后的集合为:\n");
    sort_Sq(a);        //给a集合排序
    displaylist_Sq(a);
    printf("请输入b集合的长度:\n");
    scanf("%d",&b.length);
    printf("<元素>:\n");
    for(i=0;i<b.length;i++)
    scanf("%d",&b.elem[i]);
    printf("排序后的集合为:\n");
    sort_Sq(b);      //给b集合排序
    displaylist_Sq(b);
    printf("a与b的并集为:\n");
    unionList(a,b,c);   //求a与b的并集
    printf("a与b的交集为:\n");
    mixdlist_Sq(a,b,c);    //求a与b的交集
    printf("a-b的差集为:\n");
    difrentlist_Sq(a,b,c);     //求a-b的差集
    printf("b-a的差集为:\n");
    difrentlist_Sq(b,a,c);     //求b-a的差集
    return 0;
    }

    展开全文
  • 实验 二 集合运算 //在写代码的过程中,没有注意头结点~~~ 导致出现了很多野指针~~~ ,几乎重写. 。o 0 ~~~ // 经同学检查,发现有错误~~~ 红色部分代码已经修正 //集合运算 /*选作...
  • /* ...*All right reserved. * ...*摘 要:利用单链表实现集合交并运算 * *当前版本:1.0 *作 者:邵玉胜 *完成日期:2018-12-27 */ #ifndef LINKLIST_H_ #define LINKLIST_H_ #include&lt;...
  • 数据结构–c语言链表实现集合的(,补)运算! **前言:** *进入了大二,有同学说学习数据结构像学习数学(但这里不仅仅高中数学运算那么简单!更多是逻辑和思维的训练吧!)。而本宝宝刚开始面对这门课程...
  • 数据结构与算法——查集(不相交集合)

    万次阅读 多人点赞 2019-08-28 00:13:13
    实际上查集是一种挺高效的数据结构。实现简单,只是所有元素统一遵从一个规律所以让办事情的效率高效起来。 对于定于,百科上这么定义的: 查集,在一些有N个元素的集合应用问题中,我们通常是在开始时让每个...
  • 昨天用数据结构中的线性表的顺序结构实现了关于集合、补的集合运算,做个记录,希望也能帮助到其他人。 一、算法分析  (1)用数组A,B,C,E表示集合。假定A={1,3,4,5,6,7,9,10},  B={2,,3,4...
  • 我花了一夜用数据结构给女朋友写个H5走迷宫游戏

    万次阅读 多人点赞 2019-09-10 23:27:18
    又到深夜了,我按照以往在csdn和公众号写着数据结构!这占用了我大量的时间!我的超越妹妹严重缺乏陪伴而 怨气满满! 而女朋友时常埋怨,认为数据结构这么抽象难懂的东西没啥作用,常会问道:天天写这玩意,有啥...
  • 链表实现集合运算

    千次阅读 多人点赞 2019-07-01 21:23:34
    最近在帮大一的小学弟做数据结构的课设,感觉这个题目呀比较有意思,就发出来了。 #include <stdio.h> #include <stdlib.h> #define true 1 #define false 0 typedef struct Node { int data; ...
  • 【问题描述】 编制一个能演示执行集合运算的程序【基本要求】 (1)集合的元素限定为小写字母字符[ a......z ] (2 )演示程序以用户和计算机对话的方式执行【测试数据】【实现提示】 以有序链表表示...
  • 数据结构 集合运算链表实现

    千次阅读 2018-04-15 18:10:52
    调试要求:1 实验目的本实验是要实现求集合(用单链表表示)的运算,通过该实验更深刻地理解线性结构的链表的特点。 2 实验内容实现集合(用单链表表示)的运算,在此基础上设计一个主程序...
  • 集合运算(C语言)

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

    万次阅读 多人点赞 2018-11-28 19:49:15
    编制一个能演示执行集合运算的程序。 一. 该课题研究的是:设计程序实现集合和补的混合运算;同时,可以进行集合中元素的判定、集合子集的判定和求集合的补集;还可以对不同元素类型的...
  • 使用高级程序设计语言实现集合交并差运算

    千次阅读 多人点赞 2020-05-11 20:35:57
    利用高级语言实现集合交操作 实验数据文件: R: a1 b1 c1 a1 b2 c2 a2 b2 c1 S: a1 b2 c2 a1 b3 c2 a2 b2 c1 实际输入数据为: 3 3 3 a1 b1 c1 a1 b2 c2 a2 b2 c1 a1 b2 c2 a1 b3 c2 a2 b2 c1 其中R的行数...
  • 集合 补 运算

    千次阅读 2012-10-18 12:59:09
    这是离散数学上的一个实验题,让用编程实现集合 补的运算。我这是借鉴的同学的。我自己水平还达不到啊。                                             ...
  • 集合交并运算

    千次阅读 2017-12-01 15:06:16
    数据结构链表实现集合交并运算//consts.h#include #include #include #include #include #include #include #include<process.h>#define TRUR 1 #define FALSE 0
  • 顺序表是一种简单的数据存储结构,既然把数据存起来就肯定要用,利用顺序表充当集合来实现集合的常用3种运算是一种常见的问题。代码如下: #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #...
  • 顺序表集合交并差操作

    千次阅读 2017-10-25 16:37:09
    用顺序表表示集合,设计一个算法实现集合的求交集运算 void Intersection(SqList A,SqList B,SqList &C) { int i,j,k; //k记录C中的元素个数 for(i=0; i; i++) //用i遍历顺序表A { j=0; while(j[j]!=A.da
  • ///求两个有序集合用尾插法 void InterSect(LinkList *ha,LinkList*hb,LinkList*&hc) { LinkList *pa=ha->next,*pb,*pc,*s; hc=(LinkList*)malloc(sizeof(LinkList)); pc=hc; while(pa!=NULL) { pb=hb->...
  • 集合运算

    千次阅读 2016-01-15 17:21:14
    在以单链表表示的正整数的有序集合上,实现集合运算。 基本要求: (1)用单链表存储集合中的数据; (2)对单链表中的数据进行排序。 测试数据要求: 数据中包含的整数,是随机产生的两位整数 #...
  • 题目:设计实现一个集合数据结构Set。一个集合中没有重复元素,支持下列运算: boolean add(E o) 如果 set 中尚未存在指定的元素o,则添加此元素。 boolean addAll(Set c) 如果 set 中没有指定集合c中的...
  • 数据结构集合及运算

    千次阅读 2019-08-24 18:02:30
    集合运算:、补、,判定一个元素是否属于某一集合 查集:集合并、查某元素属于什么集合 查集问题中集合存储如何实现? 可以用树结构表示集合,树的每个结点代表一个集合元素 采用数组存储形式 ...
  • 查集是一种树型的数据结构,用于处理一些不相交集合(disjoint sets)的合并及查询问题。   查集问题中集合存储如何实现?     ⋄\diamond⋄ 可以用树结构表示集合,树的每个结点代表一个集合元素。   ...
  • 集合的定义以及集合交并补运算

    千次阅读 2018-12-29 12:16:04
    //union方法:将第一个集合的元素加入临时集合,然后查看第二个集合中的元素是否属于第一个集合中的元素,如果属于,则跳过该成员;否则就将该成员加入临时集合 function union(set) { var tempSet=new Set();//...
  • 关于集合交差 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不...
  • python中的set是指一系列无序元素的集合,其中的元素都是相异的,常见的操作包括集合的并集,交集和补集等操作。 1、set的创建 格式 set_name = {value1, value2, ...} 创建空的集合 set_name = set() 注意:...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 78,105
精华内容 31,242
关键字:

数据结构集合的交并差

数据结构 订阅