单链表

/*参考单链表的基本运算，设计有序单链表的基本运算，主要功能函数如下，
1、初始化有序单链表L。
2、建立一个有序单链表L。存放一组有序数，或产生一组随机数并排序。
3、求有序单链表L的长度。
4、有序单链表L中取出第i个元素。
5、定位函数，确定有序单链表L值为e元素的位置。
6、在有序单链表L插入一个值为e的元素，使其仍有序。
7、删除有序单链表L中所有值为e的元素。
8、将有序单链表L中值为e元素修改值为e1，使其仍有序。
9、将有序单链表L中属于区间[low,high]的数据取出存入新的有序单链表L1。
10、有序单链表LA和有序单链表LB分别存储两个集合A和B，利用归并法分别求出两个集合的并集、交集和差集。*/

#include <cstdlib>
typedef int ElemType;
typedef struct LNode //定义单链表节点类型 
{
    ElemType data;
    struct LNode *next;
}LinkList;
//1、初始化有序单链表L。
void InitList(LinkList *&L)
{
  L=(LinkList *)malloc(sizeof(LinkList));
  L->next=NULL;//创建头结点，其next域置于null
}

//2、建立一个有序单链表L。存放一组有序数，或产生一组随机数并排序。
void CreateListF(LinkList *&L,ElemType a[],int n)//头插法
{
  LinkList *s;
  InitList(L);
 // L->data=a[0];
 //L->next=NULL;
  for(int i=1;i<n;i++)
  { 
    s=(LinkList *)malloc(sizeof(LinkList));
	s->data=a[i];
	s->next=L->next;
	L->next=s;
	//L=s;
  }
}
void CreateListR(LinkList *&L,ElemType a[],int n)//尾插法
{
	LinkList *s,*r;//r是尾指针
	L=(LinkList *)malloc(sizeof(LinkList));//创建头结点
	r=L;//r始终指向尾节点，开始时指向头结点
	for(int i=1;i<n;i++)
	{
		 s=(LinkList *)malloc(sizeof(LinkList));
		 s->data=a[i];//创建数据节点s
		 r->next=s;
		 r=s;	
	}
	r->next=NULL;//尾节点next域置为null
}
//3、求有序单链表L的长度。
int ListLength(LinkList *L)
{
	int n=0;
	LinkList *p=L;
	while(p->next!=NULL)
	{
		n++;
		p=p->next;

	}
	return(n); 
}

//4、有序单链表L中取出第i个元素。
int Geti(LinkList *L,int i)
{
	int j=0;
	LinkList *p=L;
	while(j<i-1&&p!=NULL)
	{
		j++;
		p=p->next;
	}
	if(p==NULL)
		return false;
	else
		return(p->data);
	
}

//5、定位函数，确定有序单链表L值为e元素的位置。
int LocateElem(LinkList *L,ElemType e)
{
	int i=1;
	LinkList *p=L->next;//p指向开始结点
	while(p!=NULL&&p->data!=e)
	{
		p=p->next;
		i++;
	}
	if(p==NULL)
		return(0);
	else
		return(i);

}

//6、在有序单链表L插入一个值为e的元素，使其仍有序。
bool ListInsert(LinkList *&L,ElemType e)
{
	int i=1;
	LinkList *q=L->next;//p指向开始结点
	while(q!=NULL&&q->data<e)
	{
		q=q->next;
		i++;
	}
	int j=0;
	LinkList *p=L,*s;
	while(j<i-1&&p!=NULL)
	{
		j++;
		p=p->next;
	}
	if(p==NULL)
		return false;
	else
	{
		 s=(LinkList *)malloc(sizeof(LinkList));//创建新节点
		 s->data=e;
		 s->next=p->next;
		 p->next=s;
		 return true;
		
	}
	
}
void ListInsert2(LinkList *&L,ElemType e)
{
     LinkList *pre=L,*p;
     while(pre->next!=NULL&&pre->next->data<e)
     pre=pre->next;
     p=(LinkList*)malloc(sizeof(LinkList));
     p->data=e;
     p->next=pre->next;
     pre->next=p;
     
}

//7、删除有序单链表L中所有值为e的元素。
void ListDelete(LinkList *&L,ElemType e)
{

	LinkList *p,*r;
	r=L;
	p=L->next;
	while(p!=NULL && p->data!=e)
	{  
		r=p; 
		p=p->next;
	}

	while(p!=NULL && p->data==e)
	{
		r->next=p->next;
		free(p);
		p=r->next; 
	
	
	}
}

//链表的排序
//冒泡排序
void bubblesort(LinkList *&L)
{
	int n=0;
	LinkList *p=L;
	while(p)
	{
		n++;
		p=p->next;
	}//这一步是为了遍历一遍链表，得出表中数据的数量
	for(int i=0;i<n;i++)
	{
		LinkList *q=NULL;
        LinkList *r=L;
		int k=0;
		int j=0;
		while(r&&r->next&&j<n-i)
		{
			if(r->data>r->next->data)
			{
				LinkList *temp=r->next;
				if(q)
				{
					q->next=temp;
				}
				else
				{	L=temp;
				}
				q=temp;
				r->next=temp->next;
				temp->next=r;
				k=0;
			}
			else
			{
				q=r;//q指向r
				r=r->next;//r后移
				k++;
			}
			j++;
		}//end while
		i=i+k;
	}//end for
}
//8、将有序单链表L中值为e元素修改值为e1，使其仍有序。
void change(LinkList *&L,ElemType e,ElemType e1)
{
	int i=1;
	LinkList *p=L->next;//p指向开始结点
	while(p!=NULL&&p->data!=e)
	{
		p=p->next;
		i++;
	}
	    p->data=e1;
//链表的排序
    bubblesort(L);

}
//9、将有序单链表L中属于区间[low,high]的数据取出存入新的有序单链表L1。
void interval(LinkList *&L,ElemType low,ElemType high,LinkList *&L1)
{
	LinkList *p,*q;
	p=L->next;
    q=p->next;
	while(p->data<low)
	{
		p=q;
		q=q->next;
	}
	L1->next=q;
	LinkList *r,*s;
	r=L->next;
	s=r->next;
	while(s->data<high)
	{
		r=s;
		s=s->next;
	}

	r->next=NULL;
	p->next=s;
	
}

//10、有序单链表LA和有序单链表LB分别存储两个集合A和B，利用归并法分别求出两个集合的并集、交集和差集。
void combine(LinkList *&LA,LinkList *&LB,LinkList *&LC)
{
	LinkList *pa,*pb,*pc;
	pa=LA->next;pb=LB->next;
	pc=LC;
	while(pa!=NULL&&pb!=NULL)
	{if(pa->data<pb->data)
	{
		pc->next=pa;
		pc=pa;
		pa=pa->next;
	}
	else if(pa->data>pb->data)
	{
		pc->next=pb;
		pb=pb->next;
	}
	else if(pa->data==pb->data)
	{
		pc->next=pa;
		pc=pa;
        pa=pa->next;
        pb=pb->next;
	}
	if(pa!=NULL)
		pc->next=pa;
	else
		pc->next=pb;
    }
}
//交集
void con(LinkList *&LA,LinkList *&LB,LinkList *&LC)
{
	LinkList *pa,*pb,*pc;
	pa=LA->next;pb=LB->next;
	pc=LC;
	while(pa!=NULL&&pb!=NULL)
	{if(pa->data<pb->data)
	{
		pc->next=pa;
		pa=pa->next;
	}
	else if(pa->data>pb->data)
	{
		pc->next=pb;
		pb=pb->next;
	}
	else if(pa->data==pb->data)
	{
		pc->next=pa;
        pc=pa;
        pa=pa->next;
        pb=pb->next;
	}
    
    }
}
//差集
void omplement(LinkList *&LA,LinkList *&LB,LinkList *&LC)
{
	LinkList *pa,*pb,*pc;
	pa=LA->next;pb=LB->next;
	pc=LC;
	while(pa!=NULL&&pb!=NULL)
	{if(pa->data<pb->data)
	{
		pc->next=pa;
		pc=pa;
		pa=pa->next;
	}
	else if(pa->data>pb->data)
	{
		pc->next=pb;
		pb=pb->next;
	}
	else if(pa->data==pb->data)
	{
		pc->next=pa;
        pa=pa->next;
        pb=pb->next;
	}
	if(pa!=NULL)
		pc->next=pa;
	else
		pc->next=pb;
    }
}

void main()
{
  LinkList *L,*L1,*LA,*LB,*LC;
 // int low,high;
  ElemType a[]={00,22,22,33,44,55,66,77};
  ElemType la[]={00,11,22,33,44}; InitList(LA);CreateListR(LA,la,5); 
  ElemType lb[]={00,33,44,66}; InitList(LB);CreateListR(LB,lb,4); 
  InitList(LC);
  combine(LA,LB,LC);
  con(LA,LB,LC);
  omplement(LA,LB,LC);
  InitList(L);InitList(L1);
  CreateListR(L,a,8); 
  interval(L,10,40,L1);
  bubblesort(L);
  //ListDelete(L,11);
  ListInsert(L,33);
  LocateElem(L,44);
  change(L,44,11);

}