顺序表和链表的交并补

狂人小魏

已于 2022-04-09 14:05:36 修改

阅读量849

点赞数 5

分类专栏： C语言数据结构文章标签： c语言

于 2022-04-06 13:42:17 首次发布

本文链接：https://blog.csdn.net/m0_55380558/article/details/123988067

版权

C语言同时被 2 个专栏收录

4 篇文章 0 订阅

订阅专栏

数据结构

3 篇文章 0 订阅

订阅专栏

已经修改了

顺序表

#include <stdio.h>
#define MAXSIZE 30
typedef int datatype;
typedef struct {
	datatype data[MAXSIZE];
	int last;
}SeqList;
void Union(SeqList A,SeqList B,SeqList *C);
void intersection(SeqList A,SeqList B,SeqList *C);
void differnce(SeqList A,SeqList B,SeqList *C);
void output(SeqList A);
int main()
{ int i=0;
  SeqList A={{20,30,40,50,60,70,80,90,100},8};
  SeqList B={{15,20,25,35,40,55,60,75,85,95},9};
  SeqList C,D,E;
  /*计算集合的并*/
  Union(A, B,&C);
  output( C);
  /*计算集合的交*/ 
  intersection( A, B, &D);
   output( D);
  /*计算集合的差*/
  differnce( A, B, &E);
   output( E);
}
void output(SeqList C)
{ int i;
for(i=0;i<=C.last;i++)
     { printf("%-6d",C.data[i]);
      if((i+1)%5==0) printf("\n");
}
  printf("\n");
}
/*集合并集运算*/
void Union(SeqList A,SeqList B,SeqList *C)
{  int i=0,j=0,k=0;
  while(i<=A.last&&j<=B.last)
  { 
	 if(A.data[i]<B.data[j])
    { /* 把A中当前元素加入到结果集合中*/
	  C->data[k]=A.data[i];
	  i++;
	  k++; 
     }
	  else if(A.data[i]==B.data[j])
	   {   /* 把A中当前元素加入到结果集合中，丢掉B集合中当前元素*/
	    C->data[k]=A.data[i];
	  i++;
	  k++;
	  j++;

}  
	 else 
	    { /* 把B中当前元素加入到结果集合中*/
	  C->data[k]=B.data[j];
	  k++;
	  j++;

     }
  }
/*如果A集合中还有剩余元素*/
 while(i<=A.last)
 { 
	C->data[k]=A.data[i];
	i++;
	k++;
  }
/*如果A集合中还有剩余元素*/
 while(j<=B.last)
 { 
C->data[k]=B.data[j];
	j++;
	k++;
 }
C->last=k-1;
}
/*集合交集运算*/
void  intersection(SeqList A,SeqList B,SeqList *C)
{ int i=0,j=0,k=0;
  while(i<=A.last&&j<=B.last)
  { 
	 if(A.data[i]<B.data[j])
	   { /*丢掉A中当前元素*/
	  i++;

     }
	 else if(A.data[i]==B.data[j])
	 {  /* 把A中当前元素加入到结果集合中，丢掉B集合中当前元素*/
	    C->data[k]=A.data[i];
	    i++;
	    j++;
	    k++;

	 }
	 else 
	   { /*丢掉B中当前元素*/
	  
		j++;
     }
  }
 C->last=k-1;
}
/*集合差集运算*/
void differnce(SeqList A,SeqList B,SeqList *C)
{ int i=0,j=0,k=0;
  while(i<=A.last&&j<B.last)
  { 
	 if(A.data[i]<B.data[j])
	   { /* 把A中当前元素加入到结果集合中*/
	  C->data[k]=A.data[i];
	  i++;
	  k++;

     }

	 else if(A.data[i]==B.data[j])
	 {  /*丢掉A中当前元素*/
/*丢掉B中当前元素*/
		i++;
		j++;
	 }
	 else 
	    { /*丢掉B中当前元素*/
	  	j++;

     }

  }
/*如果A集合中还有剩余元素，把剩余元素放到结果集合中*/
 while(i<=A.last)
 { 
	C->data[k]=A.data[i];
	i++;
  }
C->last=k-1;
}

链表

#include <stdio.h>
#include <stdlib.h>
typedef int datatype;
typedef struct node{
	datatype data;
	struct node *next;
}LNode,*LinkList;
LinkList CreateLinkList(int *,int);
LinkList Union(LinkList la,LinkList lb);
LinkList intersection(LinkList la,LinkList lb);
LinkList differnce(LinkList la,LinkList lb);
void outputLinkList(LinkList L);
int main()
{ int i=0;
  LNode *p;
  LinkList A,B,C,D,E;
  int a[]={20,30,40,50,60,70,80,90,100};
  int b[]={15,20,25,40,45,60,65,75,85,95};
  A=CreateLinkList(a,9);
// 
  B=CreateLinkList(b,10);
 // outputLinkList(B);
  /*计算集合的并*/
  printf("并");
  C= Union(A,B);
 outputLinkList(C);
  /*计算集合的交*/ 
   printf("交");
  D= intersection(A, B);
 outputLinkList(D);
  /*计算集合的差*/
   printf("差");
  E=differnce(A, B);
 outputLinkList(E);
}
/*根据数组数据创建链表存储结构*/
LinkList CreateLinkList(int a[],int n)
{ int i;
  LNode *pre,*p;
  LinkList L;
  L=pre=(LNode *)malloc(sizeof(LNode));
  for(i=0;i<n;i++)
  {  p=(LNode *)malloc(sizeof(LNode));
     p->data=a[i];
	 pre->next=p;
	 pre=p;
	 }
  pre->next=NULL;
  return(L);
}

/*集合的并运算*/
LinkList Union(LinkList la,LinkList lb)
{ LNode *pre,*p,*q,*s;
  LinkList L;
  p=la->next;
  q=lb->next;
  L=pre=(LNode *)malloc(sizeof(LNode));
  while(p&&q)
  { 
    s=(LNode *)malloc(sizeof(LNode));
	  if(p->data<q->data)
	   { /*把A集合当前元素放入结果集合中*/
			s->data=p->data;
			pre->next=s;
			pre=s;
			p=p->next;
	     }
	  else if(p->data==q->data)
	   { /*把A集合当前元素放入结果集合中*/
       /*丢掉集合B当前元素*/
		s->data=p->data;
			pre->next=s;
			pre=s;
			p=p->next;
			q=q->next;
	    }
	  else 
{ /*把B集合当前元素放入结果集合中*/
    s->data=q->data;
      pre->next=s;
      pre=s;
      q=q->next;
	    }
  }
 /*处理未处理完的链表*/
 p=p?p:q;
 while(p)
 {  
 s=(LNode *)malloc(sizeof(LNode));
 s->data=p->data;
 pre->next=s;
 pre=s;
 p=p->next;
}
 pre->next=NULL;
 return(L);
}
/*集合的交运算*/
LinkList intersection(LinkList la,LinkList lb)
{ LNode *pre,*p,*q,*s;
  LinkList L;
  p=la->next;
  q=lb->next;
  L=pre=(LNode *)malloc(sizeof(LNode));
  while(p&&q)
  { 
	 if(p->data<q->data)
	  { /*丢掉A中当前元素*/
		p=p->next;
     }
	else if(p->data==q->data)
	{ s=(LNode *)malloc(sizeof(LNode));
    /* 把A中当前元素加入到结果集合中，丢掉B集合中当前元素*/
		s->data=p->data;
		pre->next=s;
		pre=s;
		p=p->next;
		q=q->next;
	}
	else 
{ /*丢掉B中当前元素*/
	  q=q->next;

    }
	}
 pre->next=NULL;
 return(L);
}
/*集合的差运算*/
LinkList differnce(LinkList la,LinkList lb)
{ LNode *pre,*p,*q,*s;
  LinkList L;
  p=la->next;
  q=lb->next;
  L=pre=(LNode *)malloc(sizeof(LNode));
  while(p&&q)
  { 
	if(p->data<q->data)
	 { /* 把A中当前元素加入到结果集合中*/
		s=(LNode *)malloc(sizeof(LNode));
		s->data=p->data;
		pre->next=s;
		pre=s;
		p=p->next;
	} 
	else if(p->data==q->data)
	{  /*丢掉A中当前元素*/
/*丢掉B中当前元素*/
		p=p->next;
		q=q->next;
	}
	else 
	{ 
	q=q->next;
	  /*丢掉B中当前元素*/	}
  }
/*如果A集合中还有剩余元素，把剩余元素放到结果集合中*/
while(p)
 {  
 s=(LNode *)malloc(sizeof(LNode));
 s->data=p->data;
pre->next=s;
pre=s;
p=p->next;
 } 
 pre->next=NULL;
 return(L);
}
/*输出链表的值*/
void outputLinkList(LinkList L)
{ int i=0;
  LNode *p;
  p=L->next;
  while(p)
  { printf("%-6d",p->data);
    p=p->next;
    i++;
	if(i%10==0) printf("\n");
  }
printf("\n");
}