一、单链表、循环单链表、循环双链表各自特点
链表是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每个节点里存到下一个节点的指针。由于不须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比顺序表O(logn)快得多，但是查找一个节点或者访问特定编号的节点则需要O(n)的时间，而顺序表的时间复杂度是O(1)。
链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理。但是链表失去了数组随机读取的优点，同时链表由于增加了结点的指针域，空间开销比较大。
链表由一连串节点组成，每个节点包含任意的实例数据(data fields)和一或两个用来指向明上一个/或下一个节点的位置的链接（"links"）。链表是一种自我指示数据类型，因为它包含指向另一个相同类型的数据的指针。链表允许插入和移除表上任意位置上的节点，但是不允许随机存取。链表有很多种不同的类型：单向链表，双向链表以及循环链表。
链表可以在多种编程语言中实现。
1、单向链表或者单链表
单向链表，它包含两个域，一个信息域和一个指针域。这个链接指向表中的下一个节点，而最后一个节点则指向一个空值NULL。
单向链表只可向一个方向遍历。
查找一个节点的时候需要从第一个节点开始每次访问下一个节点，一直访问到需要的位置。也可以提前把一个节点的位置另外保存起来，然后直接访问。
2、 双向链表,也叫双链表
双向链表中不仅有指向后一个节点的指针，还有指向前一个节点的指针。第一个节点的"前连接"指向NULL，最后一个节点的"后连接"指向NULL。
这样可以从任何一个节点访问前一个节点，也可以访问后一个节点，以至整个链表。一般是在需要大批量的另外储存数据在链表中的位置的时候用。
由于另外储存了指向链表内容的指针，并且可能会修改相邻的节点，有的时候第一个节点可能会被删除或者在之前添加一个新的节点。这时候就要修改指向首个节点的指针。
有一种方便的可以消除这种特殊情况的方法是在最后一个节点之后、第一个节点之前储存一个永远不会被删除或者移动的虚拟节点，形成一个循环链表。这个虚拟节点之后的节点就是真正的第一个节点。这种情况通常可以用这个虚拟节点直接表示这个链表。
3、 循环链表
在一个循环链表中, 首节点和末节点被连接在一起。这种方式在单向和双向链表中皆可实现。要转换一个循环链表，你开始于任意一个节点然后沿着列表的任一方向直到返回开始的节点。循环链表可以被视为"无头无尾"。
循环链表中第一个节点之前就是最后一个节点，反之亦然。循环链表的无边界使得在这样的链表上设计算法会比普通链表更加容易。对于新加入的节点应该是在第一个节点之前还是最后一个节点之后可以根据实际要求灵活处理，区别不大。
另外有一种模拟的循环链表，就是在访问到最后一个节点之后的时候，手工跳转到第一个节点。访问到第一个节点之前的时候也一样。这样也可以实现循环链表的功能，在直接用循环链表比较麻烦或者可能会出现问题的时候可以用。
其它
链表中的节点不需要以特定的方式存储，但是集中存储也是可以的，主要分下面这几种具体的存储方法：
共用存储空间：链表的节点和其它的数据共用存储空间，优点是可以存储无限多的内容（不过要处理器支持这个大小，并且存储空间足够的情况下），不需要提前分配内存,存储一个申请一个，如C语言的MALLOC；缺点是由于内容分散，有时候可能不方便调试。
独立存储空间：一个链表或者多个链表使用独立的存储空间，一般用数组或者类似结构实现，优点是可以自动获得一个附加数据：唯一的编号/索引，并且方便调试；缺点是不能动态的分配内存。当然，另外的在上面加一层块状链表用来分配内存也是可以的，这样就解决了这个问题。这种方法叫做数组模拟链表，但是事实上只是用表示在数组中的位置的下标索引代替了指向内存地址的指针，这种下标索引其实也是逻辑上的指针，整个结构还是链表，并不算是被模拟的（但是可以说成是用数组实现的链表）。
链表用来构建许多其它数据结构，如堆栈，行列和他们的衍生。
节点的数据域也可以成为另一个链表。通过这种手段，我们可以用列表来构建许多链性数据结构；这个实例产生于Lisp编程语言，在Lisp中链表是初级数据结构，并且现在成为了常见的基础编程模式。 有时候，链表用来生成联合数组，在这种情况下我们称之为联合数列。这种情况下用链表会优于其它数据结构，如自平对分查找树（self-balancing binary search trees）甚至是一些小的数据集合。不管怎样，一些时候一个链表在这样一个树中建立一个节点子集，并且以此来更有效率地转换这个集合。
二、 顺序表、单链表、双链表、有序单链表 算法与实现
1、顺序表的实现
#include <stdio.h>
#include <malloc.h>
#define MaxSize 50
typedef char ElemType;
typedef struct
{
ElemType data[MaxSize];
int length;
}SqList;
void InitList(SqList *&L)
{
L = (SqList *)malloc(sizeof(SqList));
L->length = 0;
}
void DestroyList(SqList *L)
{
free(L);
}
int ListEmpty(SqList *L)
{
return(L->length==0);
}
int ListLength(SqList *L)
{
return(L->length);
}
void DispList(SqList *L)
{
int i;
if (ListEmpty(L))
{
return ;
}
for(i = 0;i < L->length;i++)
{
printf("%c",L->data[i]);
}
printf("\n");
}
int GetElem(SqList *L,int i,ElemType &e)
{
if (i<1||i>L->length)
{
return 0;
}
e = L->data[i-1];
return 1;
}
int LocateElem(SqList *L, ElemType e)
{
int i = 0;
while(i<L->length&&L->data[i]!=e)
i++;
if (i>L->length)
{
return 0 ;
}
else
{
return i+1;
}
}
int ListInsert(SqList *&L,int i,ElemType e)
{
int j;
if (i<1||i>L->length+1)
{
return 0;
}
i--;
for (j = L->length;j>i;j--)
{
L->data[j]=L->data[j-1];
}
L->data[i] = e;
L->length++;
return 1;
}
int ListDelete(SqList *&L,int i,ElemType &e)
{
int j;
if (i<1||i>L->length)
{
return 0;
}
i--;
e = L->data[i];
for (j = i;j<L->length-1;j++)
{
L->data[j] = L->data[j+1];
}
L->length--;
return 1;
}
int main()
{
SqList *L;
ElemType e;
printf("初始化顺序表L\n");
InitList(L);
printf("依次采用尾插法插入a,b,c,d,e元素\n");
ListInsert(L,1,'a');
ListInsert(L,2,'b');
ListInsert(L,3,'c');
ListInsert(L,4,'d');
ListInsert(L,5,'e');
printf("输出顺序表L:");
DispList(L);
printf("顺序表L长度=%d\n",ListLength(L));
printf("顺序表L为%s\n",(ListEmpty(L)?"空":"非空"));
GetElem(L,3,e);
printf("顺序表L的第3个元素=%c\n",e);
printf("在第四个元素位置上插入f元素\n");
ListInsert(L,4,'f');
printf("输出顺序表L:");
DispList(L);
printf("删除L的第3个元素\n");
ListDelete(L,3,e);
printf("输出顺序表L:");
DispList(L);
printf("释放顺序表L\n");
DestroyList(L);
return 0;
}
2、单链表的实现
#include <stdio.h>
#include <malloc.h>
typedef char ElemType;
typedef struct LNode
{
ElemType data;
struct LNode *next;
}LinkList;
void InitList(LinkList *&L)
{
L = (LinkList *)malloc(sizeof(LinkList));
L->next = NULL;
}
void DestroyList(LinkList *&L)
{
LinkList *p = L,*q = p->next;
while(q!=NULL)
{
free(p);
p = q;
q = p->next;
}
free(p);
}
int ListEmpty(LinkList *L)
{
return(L->next==NULL);
}
int ListLength(LinkList *L)
{
LinkList *p = L;
int i = 0;
while(p->next!=NULL)
{
i++;
p = p->next;
}
return(i);
}
void DispList(LinkList *L)
{
LinkList *p = L->next;
while(p!=NULL)
{
printf("%c",p->data);
p = p->next;
}
printf("\n");
}
int GetElem(LinkList *L,int i,ElemType &e)
{
int j = 0;
LinkList *p = L;
while(j<i&&p!=NULL)
{
j++;
p = p->next;
}
if (p == NULL)
{
return 0 ;
}
else
{
e = p->data;
return 1;
}
}
int LocateElem(LinkList *L,ElemType e)
{
LinkList *p = L->next;
int n = 1;
while (p!=NULL&&p->data!=e)
{
p = p->next;
n++;
}
if (p == NULL)
{
return(0);
}
else
{
return(n);
}
}
int ListInsert(LinkList *&L,int i,ElemType e)
{
int j = 0;
LinkList *p = L,*s;
while(j<i-1&&p!=NULL)
{
j++;
p = p->next;
}
if (p == NULL)
{
return 0;
}
else
{
s = (LinkList *)malloc(sizeof(LinkList));
s->data = e;
s->next = p->next;
p->next = s;
return 1;
}
}
int ListDelete(LinkList *&L,int i,ElemType &e)
{
int j = 0;
LinkList *p = L,*q;
while (j<i-1&&p!=NULL)
{
j++;
p = p->next;
}
if (p == NULL)
{
return 0;
}
else
{
q = p->next;
if (q == NULL)
return 0;
e = q->data;
p->next = q->next;
free(q);
return 1;
}
}
int main()
{
LinkList *h;
ElemType e;
printf("(1)初始化单链表h\n");
InitList(h);
printf("(2)依次采用尾插法插入a,b,c,d,e元素\n");
ListInsert(h,1,'a');
ListInsert(h,2,'b');
ListInsert(h,3,'c');
ListInsert(h,4,'d');
ListInsert(h,5,'e');
printf("(3)输出单链表h:");
DispList(h);
printf("(4)单链表h长度=%d\n",ListLength(h));
printf("(5)单链表h为%s\n",(ListEmpty(h)?"空":"非空"));
GetElem(h,3,e);
printf("(6)单链表h的第3个元素=%c\n",e);
printf("(7)元素a的位置=%d\n",LocateElem(h,'a'));
printf("(8)在第4个元素位置上插入f元素\n");
ListInsert(h,4,'f');
printf("(9)输出单链表h:");
DispList(h);
printf("(10)删除h的第3个元素\n");
ListDelete(h,3,e);
printf("(11)输出单链表h:");
DispList(h);
printf("(12)释放单链表h\n");
DestroyList(h);
}
3、双链表的实现
#include <stdio.h>
#include <malloc.h>
typedef char ElemType;
typedef struct DNode
{
ElemType data;
struct DNode *prior;
struct DNode *next;
}DLinkList;
void InitList(DLinkList *&L)
{
L = (DLinkList *)malloc(sizeof(DLinkList));
L->prior = L->next = NULL;
}
void DestroyList(DLinkList *&L)
{
DLinkList *p = L,*q = p->next;
while(q!=NULL)
{
free(p);
p = q;
q = p->next;
}
free(p);
}
int ListEmpty(DLinkList *L)
{
return(L->next == NULL);
}
int ListLength(DLinkList *L)
{
DLinkList *p = L;
int i = 0;
while(p->next!=NULL)
{
i++;
p = p->next;
}
return(i);
}
void DispList(DLinkList *L)
{
DLinkList *p = L->next;
while (p!=NULL)
{
printf("%c",p->data);
p= p->next;
}
printf("\n");
}
int GetElem(DLinkList *L,int i,ElemType &e)
{
int j = 0;
DLinkList *p = L;
while (j<i&&p!=NULL)
{
j++;
p = p->next;
}
if (p == NULL)
{
return 0;
}
else
{
e = p->data;
return 1;
}
}
int LocateElem(DLinkList *L,ElemType e)
{
int n = 1;
DLinkList *p = L->next;
while(p!=NULL&&p->data!=e)
{
n++;
p= p->next;
}
if (p==NULL)
{
return(0);
}
else
return(n);
}
int ListInsert(DLinkList *&L,int i,ElemType e)
{
int j = 0;
DLinkList *p = L,*s;
while (j<i-1&&p!=NULL)
{
j++;
p = p->next;
}
if (p == NULL)
{
return 0;
}
else
{
s = (DLinkList *)malloc(sizeof(DLinkList));
s->data = e;
s->next = p->next;
if (p->next!=NULL)
{
p->next->prior = s;
}
s->prior = p;
p->next = s;
return 1;
}
}
int ListDelete(DLinkList *&L,int i,ElemType &e)
{
int j = 0;
DLinkList *p = L,*q;
while(j<i-1&&p!=NULL)
{
j++;
p = p->next;
}
if (p == NULL)
{
return 0;
}
else
{
q = p->next;
if (q == NULL)
{
return 0;
}
e = q->data;
p->next = q->next;
if (p->next!=NULL)
{
p->next->prior = p;
}
free(q);
return 1;
}
}
void main()
{
DLinkList *h;
ElemType e;
printf("(1)初始化双链表h\n");
InitList(h);
printf("(2)依次采用尾插法插入a,b,c,d,e元素\n");
ListInsert(h,1,'a');
ListInsert(h,2,'b');
ListInsert(h,3,'c');
ListInsert(h,4,'d');
ListInsert(h,5,'e');
printf("(3)输出双链表h:");
DispList(h);
printf("(4)双链表h长度=%d\n",ListLength(h));
printf("(5)双链表h为%s\n",(ListEmpty(h)?"空":"非空"));
GetElem(h,3,e);
printf("(6)双链表h的第3个元素=%c\n",e);
printf("(7)元素a的位置=%d\n",LocateElem(h,'a'));
printf("(8)在第4个元素位置上插入f元素\n");
ListInsert(h,4,'f');
printf("(9)输出双链表h:");
DispList(h);
printf("(10)删除h的第3个元素\n");
ListDelete(h,3,e);
printf("(11)输出双链表h:");
DispList(h);
printf("(12)释放双链表h\n");
DestroyList(h);
}
4、循环单链表的实现
#include <stdio.h>
#include <malloc.h>
typedef char ElemType;
typedef struct LNode//定义单链表结点类型
{
ElemType data;
struct LNode *next;
} LinkList;
void InitList(LinkList *&L)
{
L=(LinkList *)malloc(sizeof(LinkList));//创建头结点
L->next=L;
}
void DestroyList(LinkList *&L)
{
LinkList *p=L,*q=p->next;
while (q!=L)
{
free(p);
p=q;
q=p->next;
}
free(p);
}
int ListEmpty(LinkList *L)
{
return(L->next==L);
}
int ListLength(LinkList *L)
{
LinkList *p=L;int i=0;
while (p->next!=L)
{
i++;
p=p->next;
}
return(i);
}
void DispList(LinkList *L)
{
LinkList *p=L->next;
while (p!=L)
{
printf("%c",p->data);
p=p->next;
}
printf("\n");
}
int GetElem(LinkList *L,int i,ElemType &e)
{
int j=0;
LinkList *p;
if (L->next!=L)//单链表不为空表时
{
if (i==1)
{
e=L->next->data;
return 1;
}
else//i不为1时
{
p=L->next;
while (j<i-1 && p!=L)
{
j++;
p=p->next;
}
if (p==L)
return 0;
else
{
e=p->data;
return 1;
}
}
}
else//单链表为空表时
return 0;
}
int LocateElem(LinkList *L,ElemType e)
{
LinkList *p=L->next;
int n=1;
while (p!=L && p->data!=e)
{
p=p->next;
n++;
}
if (p==L)
return(0);
else
return(n);
}
int ListInsert(LinkList *&L,int i,ElemType e)
{
int j=0;
LinkList *p=L,*s;
if (p->next==L || i==1)//原单链表为空表或i==1时
{
s=(LinkList *)malloc(sizeof(LinkList));//创建新结点*s
s->data=e;
s->next=p->next;//将*s插入到*p之后
p->next=s;
return 1;
}
else
{
p=L->next;
while (j<i-2 && p!=L)
{
j++;
p=p->next;
}
if (p==L)//未找到第i-1个结点
return 0;
else//找到第i-1个结点*p
{
s=(LinkList *)malloc(sizeof(LinkList));//创建新结点*s
s->data=e;
s->next=p->next;//将*s插入到*p之后
p->next=s;
return 1;
}
}
}
int ListDelete(LinkList *&L,int i,ElemType &e)
{
int j=0;
LinkList *p=L,*q;
if (p->next!=L)//原单链表不为空表时
{
if (i==1)//i==1时
{
q=L->next;//删除第1个结点
e=q->data;
L->next=q->next;
free(q);
return 1;
}
else//i不为1时
{
p=L->next;
while (j<i-2 && p!=L)
{
j++;
p=p->next;
}
if (p==L)//未找到第i-1个结点
return 0;
else//找到第i-1个结点*p
{
q=p->next;//q指向要删除的结点
e=q->data;
p->next=q->next;//从单链表中删除*q结点
free(q);//释放*q结点
return 1;
}
}
}
else return 0;
}
void main()
{
LinkList *h;
ElemType e;
printf("(1)初始化循环单链表h\n");
InitList(h);
printf("(2)依次采用尾插法插入a,b,c,d,e元素\n");
ListInsert(h,1,'a');
ListInsert(h,2,'b');
ListInsert(h,3,'c');
ListInsert(h,4,'d');
ListInsert(h,5,'e');
printf("(3)输出循环单链表h:");
DispList(h);
printf("(4)循环单链表h长度=%d\n",ListLength(h));
printf("(5)循环单链表h为%s\n",(ListEmpty(h)?"空":"非空"));
GetElem(h,3,e);
printf("(6)循环单链表h的第3个元素=%c\n",e);
printf("(7)元素a的位置=%d\n",LocateElem(h,'a'));
printf("(8)在第4个元素位置上插入f元素\n");
ListInsert(h,4,'f');
printf("(9)输出循环单链表h:");
DispList(h);
printf("(10)删除h的第3个元素\n");
ListDelete(h,3,e);
printf("(11)输出循环单链表h:");
DispList(h);
printf("(12)释放循环单链表h\n");
DestroyList(h);
}
5、循环双链表的实现
#include <stdio.h>
#include <malloc.h>
typedef char ElemType;
typedef struct DNode//定义双链表结点类型
{
ElemType data;
struct DNode *prior;//指向前驱结点
struct DNode *next;//指向后继结点
} DLinkList;
void InitList(DLinkList *&L)
{
L=(DLinkList *)malloc(sizeof(DLinkList)); //创建头结点
L->prior=L->next=L;
}
void DestroyList(DLinkList *&L)
{
DLinkList *p=L,*q=p->next;
while (q!=L)
{
free(p);
p=q;
q=p->next;
}
free(p);
}
int ListEmpty(DLinkList *L)
{
return(L->next==L);
}
int ListLength(DLinkList *L)
{
DLinkList *p=L;int i=0;
while (p->next!=L)
{
i++;
p=p->next;
}
return(i);
}
void DispList(DLinkList *L)
{
DLinkList *p=L->next;
while (p!=L)
{
printf("%c",p->data);
p=p->next;
}
printf("\n");
}
int GetElem(DLinkList *L,int i,ElemType &e)
{
int j=0;
DLinkList *p;
if (L->next!=L)//双链表不为空表时
{
if (i==1)
{
e=L->next->data;
return 1;
}
else//i不为1时
{
p=L->next;
while (j<i-1 && p!=L)
{
j++;
p=p->next;
}
if (p==L)
return 0;
else
{
e=p->data;
return 1;
}
}
}
else//双链表为空表时
return 0;
}
int LocateElem(DLinkList *L,ElemType e)
{
int n=1;
DLinkList *p=L->next;
while (p!=NULL && p->data!=e)
{
n++;
p=p->next;
}
if (p==NULL)
return(0);
else
return(n);
}
int ListInsert(DLinkList *&L,int i,ElemType e)
{
int j=0;
DLinkList *p=L,*s;
if (p->next==L)//原双链表为空表时
{
s=(DLinkList *)malloc(sizeof(DLinkList));//创建新结点*s
s->data=e;
p->next=s;s->next=p;
p->prior=s;s->prior=p;
return 1;
}
else if (i==1)//原双链表不为空表但i=1时
{
s=(DLinkList *)malloc(sizeof(DLinkList));//创建新结点*s
s->data=e;
s->next=p->next;p->next=s;//将*s插入到*p之后
s->next->prior=s;s->prior=p;
return 1;
}
else
{
p=L->next;
while (j<i-2 && p!=L)
{j++;
p=p->next;
}
if (p==L)//未找到第i-1个结点
return 0;
else//找到第i-1个结点*p
{
s=(DLinkList *)malloc(sizeof(DLinkList));//创建新结点*s
s->data=e;
s->next=p->next;//将*s插入到*p之后
if (p->next!=NULL) p->next->prior=s;
s->prior=p;
p->next=s;
return 1;
}
}
}
int ListDelete(DLinkList *&L,int i,ElemType &e)
{
int j=0;
DLinkList *p=L,*q;
if (p->next!=L)//原双链表不为空表时
{
if (i==1)//i==1时
{
q=L->next;//删除第1个结点
e=q->data;
L->next=q->next;
q->next->prior=L;
free(q);
return 1;
}
else//i不为1时
{
p=L->next;
while (j<i-2 && p!=NULL)
{
j++;
p=p->next;
}
if (p==NULL)//未找到第i-1个结点
return 0;
else//找到第i-1个结点*p
{
q=p->next;//q指向要删除的结点
if (q==NULL) return 0;//不存在第i个结点
e=q->data;
p->next=q->next;//从单链表中删除*q结点
if (p->next!=NULL) p->next->prior=p;
free(q);//释放*q结点
return 1;
}
}
}
else return 0;//原双链表为空表时
}
void main()
{
DLinkList *h;
ElemType e;
printf("(1)初始化循环双链表h\n");
InitList(h);
printf("(2)依次采用尾插法插入a,b,c,d,e元素\n");
ListInsert(h,1,'a');
ListInsert(h,2,'b');
ListInsert(h,3,'c');
ListInsert(h,4,'d');
ListInsert(h,5,'e');
printf("(3)输出循环双链表h:");
DispList(h);
printf("(4)循环双链表h长度=%d\n",ListLength(h));
printf("(5)循环双链表h为%s\n",(ListEmpty(h)?"空":"非空"));
GetElem(h,3,e);
printf("(6)循环双链表h的第3个元素=%c\n",e);
printf("(7)元素a的位置=%d\n",LocateElem(h,'a'));
printf("(8)在第4个元素位置上插入f元素\n");
ListInsert(h,4,'f');
printf("(9)输出循环双链表h:");
DispList(h);
printf("(10)删除h的第3个元素\n");
ListDelete(h,3,e);
printf("(11)输出循环双链表h:");
DispList(h);
printf("(12)释放循环双链表h\n");
DestroyList(h);
}
6、有序单链表的和、交、并、差实现
#include <stdio.h>
#include <malloc.h>
typedef char ElemType;
typedef struct LNode//定义单链表结点类型
{
ElemType data;
struct LNode *next;
} LinkList;
void DispList(LinkList *L)
{
LinkList *p=L->next;
while (p!=NULL)
{
printf("%c",p->data);
p=p->next;
}
printf("\n");
}
void CreateListR(LinkList *&L,ElemType a[],int n) //尾插法建表
{
LinkList *s,*r;int i;
L=(LinkList *)malloc(sizeof(LinkList));//创建头结点
L->next=NULL;
r=L;//r始终指向终端结点,开始时指向头结点
for (i=0;i<n;i++)
{
s=(LinkList *)malloc(sizeof(LinkList));//创建新结点
s->data=a[i];
r->next=s;//将*s插入*r之后
r=s;
}
r->next=NULL;//终端结点next域置为NULL
}
void Sort(LinkList *&head)//单链表元素排序
{
LinkList *p=head->next,*q,*r;
if (p!=NULL)//若原单链表中有一个或以上的数据结点
{
r=p->next;//r保存*p结点后继结点的指针
p->next=NULL;//构造只含一个数据结点的有序表
p=r;
while (p!=NULL)
{
r=p->next;//r保存*p结点后继结点的指针
q=head;
while (q->next!=NULL && q->next->data<p->data)//在有序表中找插入*p的前驱结点*q
q=q->next;
p->next=q->next;//将*p插入到*q之后
q->next=p;
p=r;
}
}
}
void Union(LinkList *ha,LinkList *hb,LinkList *&hc) //求两有序集合的并
{
LinkList *pa=ha->next,*pb=hb->next,*s,*tc;
hc=(LinkList *)malloc(sizeof(LinkList));//创建头结点
tc=hc;
while (pa!=NULL && pb!=NULL)
{
if (pa->data<pb->data)
{
s=(LinkList *)malloc(sizeof(LinkList));//复制结点
s->data=pa->data;
tc->next=s;tc=s;
pa=pa->next;
}
else if (pa->data>pb->data)
{
s=(LinkList *)malloc(sizeof(LinkList));//复制结点
s->data=pb->data;
tc->next=s;tc=s;
pb=pb->next;
}
else
{
s=(LinkList *)malloc(sizeof(LinkList));//复制结点
s->data=pa->data;
tc->next=s;tc=s;
pa=pa->next;//重复的元素只复制一个
pb=pb->next;
}
}
if (pb!=NULL) pa=pb;//复制余下的结点
while (pa!=NULL)
{
s=(LinkList *)malloc(sizeof(LinkList));//复制结点
s->data=pa->data;
tc->next=s;tc=s;
pa=pa->next;
}
tc->next=NULL;
}
void InterSect(LinkList *ha,LinkList *hb,LinkList *&hc)//求两有序集合的差
{
LinkList *pa=ha->next,*pb,*s,*tc;
hc=(LinkList *)malloc(sizeof(LinkList));
tc=hc;
while (pa!=NULL)
{
pb=hb->next;
while (pb!=NULL && pb->data<pa->data)
pb=pb->next;
if (pb!=NULL && pb->data==pa->data)//若pa结点值在B中
{
s=(LinkList *)malloc(sizeof(LinkList));//复制结点
s->data=pa->data;
tc->next=s;tc=s;
}
pa=pa->next;
}
tc->next=NULL;
}
void Subs(LinkList *ha,LinkList *hb,LinkList *&hc)//求两有序集合的差
{
LinkList *pa=ha->next,*pb,*s,*tc;
hc=(LinkList *)malloc(sizeof(LinkList));
tc=hc;
while (pa!=NULL)
{
pb=hb->next;
while (pb!=NULL && pb->data<pa->data)
pb=pb->next;
if (!(pb!=NULL && pb->data==pa->data))//若pa结点值不在B中
{
s=(LinkList *)malloc(sizeof(LinkList));//复制结点
s->data=pa->data;
tc->next=s;tc=s;
}
pa=pa->next;
}
tc->next=NULL;
}
void main()
{
LinkList *ha,*hb,*hc;
ElemType a[]={'c','a','e','h'};
ElemType b[]={'f','h','b','g','d','a'};
CreateListR(ha,a,4);
CreateListR(hb,b,6);
printf("原 集 合A:");DispList(ha);
printf("原 集 合B:");DispList(hb);
Sort(ha);
Sort(hb);
printf("有序集合A:");DispList(ha);
printf("有序集合B:");DispList(hb);
Union(ha,hb,hc);
printf("集合的并C:");DispList(hc);
InterSect(ha,hb,hc);
printf("集合的交C:");DispList(hc);
Subs(ha,hb,hc);
printf("集合的差C:");DispList(hc);
}
