数据结构之求求集合的并交差大致代码（内有错误）

#include <iostream>
#include <malloc.h>
using namespace std;
typedef  int Elemtype;
typedef struct LNode  
{
	Elemtype data;
	struct LNode *next;		
} LinkNode;	
/*******************************************
********************************************/ 				
void CreateListF(LinkNode *&L,Elemtype a[],int n)    //头插法建立单链表
{
	LinkNode *s;int i; 
	L=(LinkNode *)malloc(sizeof(LinkNode));  	
	L->next=NULL;
	for (i=0;i<n;i++)
	{	
		s=(LinkNode *)malloc(sizeof(LinkNode));
		s->data=a[i];
		s->next=L->next;			
		L->next=s;
	}
}
/*******************************************
********************************************/ 
void CreateListR(LinkNode *&L,Elemtype a[],int n)   //尾插法建立单链表
{
	LinkNode *s,*r;
	L=(LinkNode *)malloc(sizeof(LinkNode));  	
	L->next=NULL;
	r=L;				
	for (int i=0;i<n;i++)
	{	
		s=(LinkNode *)malloc(sizeof(LinkNode));
		s->data=a[i];
		r->next=s;			
		r=s;
	}
	r->next=NULL;			
}
/*******************************************
********************************************/ 
void InitList(LinkNode *&L)
{
	L=(LinkNode *)malloc(sizeof(LinkNode));  	//初始化单链表 
	L->next=NULL;
}
/*******************************************
********************************************/ 
void DestroyList(LinkNode *&L)       //释放单链表      
{
	LinkNode *pre=L,*p=pre->next;
	while (p!=NULL)
	{	free(pre);
		pre=p;
		p=pre->next;
	}
	free(pre);	
}
/*******************************************
********************************************/ 
bool ListEmpty(LinkNode *L)           //判空 
{
	return(L->next==NULL);
}
/*******************************************
********************************************/ 
int ListLength(LinkNode *L)         //求链表的长度 
{
	LinkNode *p=L;int i=0;
	while (p->next!=NULL)
	{	i++;
		p=p->next;
	}
	return(i);
}
/*******************************************
********************************************/ 
void DispList(LinkNode *L)    //  输出链表         
{
	LinkNode *p=L->next;
	while (p!=NULL)
	{	printf("%c ",p->data);
		p=p->next;
	}
	printf("
");
}
/*******************************************
********************************************/ 
bool GetElem(LinkNode *L,int i)
{                                        // 根据下标查元素 
	int j=0;
	LinkNode *p=L;
	if (i<=0) return false;		
	while (j<i && p!=NULL)
	{	j++;
		p=p->next;
	}
	if (p==NULL)			
		return false;
	else					
	{	
		printf("%c
",p->data);
	}
}
/*******************************************
********************************************/ 
int LocateElem(LinkNode *L,Elemtype e)  //按元素查找下标 
{
	LinkNode *p=L->next;
	int n=1;
	while (p!=NULL && p->data!=e)
	{	p=p->next;
		n++;
	}
	if (p==NULL)
		return(0);
	else
		printf("%d
",n);
}
/*******************************************
********************************************/ 
bool ListInsert(LinkNode *&L,int i,Elemtype e)  //插入元素 
{
	int j=0;
	LinkNode *p=L,*s;
	if (i<=0) return false;			
	while (j<i-1 && p!=NULL)		
	{	j++;
		p=p->next;
	}
	if (p==NULL)					
		return false;
	else							
	{	s=(LinkNode *)malloc(sizeof(LinkNode));
		s->data=e;
		s->next=p->next;			
		p->next=s;
		return true;
	}
}
/*******************************************
********************************************/ 
bool ListDelete(LinkNode *&L,int i,Elemtype &e)//删除元素 
{
	int j=0;
	LinkNode *p=L,*q;
	if (i<=0) 
	return false;		
	while (j<i-1 && p!=NULL)	
	{	j++;
		p=p->next;
	}
	if (p==NULL)			
		return false;
	else					
	{	q=p->next;				
		if (q==NULL) 
			return false;	
		e=q->data;
		p->next=q->next;		
		free(q);				
		return true;
	}
}
/*******************************************
********************************************/ 
bool isEqual(LinkNode *L, int ListElem, int judgeElem)//判断相等 
{
	for(int i=0;i<ListLength(L);i++)
	{
		GetElem(L ,ListElem);
		if(judgeElem== ListElem)
		{
			return true;
		}
	}
	return false;
}
/*******************************************
********************************************/ 
 
void BubbleSort( LNode * L) { //冒泡排序 
	struct LNode * p, * q, * x;

	x = NULL;

	while((L->next->next) != x) {
		p = L;
		q = L->next;
		while(q->next != x) {
			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;
		}
		x = q;
	}
}
/*******************************************
********************************************/ 

LinkNode ListMerge(LinkNode *L1,LinkNode *L2) {  //有序的才合并，所以传进来的是有序表 ,二路归并 
	LNode *p, *q;
    p=L1->next,q=L2->next;
	LinkNode 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;
} 
/*=====================================
=======================================*/
LinkNode ListIntersect(LinkNode &L1,LinkNode &L2) //交运算 
{
	LinkNode p=L1->next,q=L2->next;
	LinkNode 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;
}  
/*=====================================
=======================================*/ 
LinkNode ListDifferent(LinkNode &L1,LinkNode &L2) {//差运算 
	LinkNode p=L1->next,q=L2->next;
	LinkNode 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()
{
     LinkNode *LA,*LB,*LC,*LD,*LE;
     InitList(LA);
     InitList(LB);
     int a[10] = {1,2,3,4,5,6,7,8,9,10 };
     int b[10] = {3,4,7,11,56,23,21,102,9,5};
     cout << "集合A:";
     CreateListR(LA, a, 10);  
     DispList(LA);
     cout << "集合B:";
     CreateListR(LB, b, 10);
     DispList(LB);
     cout<<"sort LA and LB
";
     
     BubbleSort(LA);
     BubbleSort(LB);
     
     LC=ListMerge(LA,LB);
	 printf("集合的并C：");
	 DispList(LC);
     
	 LD=ListIntersect(LA,LB);
	 printf("集合的交C：");
	 DispList(LD);
	
	 LE=ListDifferent(LA,LB);
	 printf("集合的差C：");
	 DispList(LE);
     DestroyList(LA);
     DestroyList(LB);

     return 0;
}