线性表的基本操作
对于不同的应用，线性表的基本操作是不同的，上诉操作是最基本的，对于实际问题中涉及的关于线性表的更复杂操作，完全可以用这些基本操作的组合来实现。如要使得A = A U B,就是要将存在于集合B中但不存在于集合A中的元素插入到集合A中即可。
/*将所有的在线性表Lb中但不在La中的数据元素插入到La中*/
void unionL(SqList *La,SqList Lb)
{
int La_len,Lb_len,i;
ElemType e; /*声明与La和Lb相同的数据元素e*/
La_len=ListLength(*La); /*求线性表的长度 */
Lb_len=ListLength(Lb);
for (i=1;i<=Lb_len;i++)
{
GetElem(Lb,i,&e); /*取Lb中第i个数据元素赋给e*/
if (!LocateElem(*La,e)) /*La中不存在和e相同数据元素*/
ListInsert(La,++La_len,e); /*插入*/
}
}一、线性表的顺序存储结构
#define MAXSIZE 20 /* 存储空间初始分配量 */
typedef int ElemType; /* ElemType类型根据实际情况而定，这里为int */
typedef struct
{
ElemType data[MAXSIZE]; /* 数组，存储数据元素 */
int length; /* 线性表当前长度 */
}SqList;存取性能为O(1)，随机存取结构
获得元素操作
#define OK 1
#define ERROR 0
/* Status是函数的类型,其值是函数结果状态代码，如OK等 */
typedef int Status;
/* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L) */
/* 操作结果：用e返回L中第i个数据元素的值，注意i是指位置，第1个位置的数组是从0开始 */
Status GetElem(SqList L,int i,ElemType *e)
{
if(L.length==0 || i<1 || i>L.length)
return ERROR;
*e=L.data[i-1];
return OK;
}插入操作
/* 初始条件：顺序线性表L已存在,1≤i≤ListLength(L)， */
/* 操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1 */
Status ListInsert(SqList *L,int i,ElemType e)
{
int k;
if (L->length==MAXSIZE) /* 顺序线性表已经满 */
return ERROR;
if (i<1 || i>L->length+1) /* 当i比第一位置小或者比最后一位置后一位置还要大时 */
return ERROR;
if (i<=L->length) /* 若插入数据位置不在表尾 */
{
for(k=L->length-1;k>=i-1;k--) /* 将要插入位置后的元素向后移一位 */
L->data[k+1]=L->data[k];
}
L->data[i-1]=e; /* 将新元素插入 */
L->length++;
return OK;
}删除操作
/* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L) */
/* 操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1 */
Status ListDelete(SqList *L,int i,ElemType *e)
{
int k;
if (L->length==0) /* 线性表为空 */
return ERROR;
if (i<1 || i>L->length) /* 删除位置不正确 */
return ERROR;
*e=L->data[i-1];
if (i<L->length) /* 如果删除不是最后位置 */
{
for(k=i;k<L->length;k++) /* 将删除位置后继元素前移 */
L->data[k-1]=L->data[k];
}
L->length--;
return OK;
}二、单链表的存储结构
链表中第一个节点的存储位置叫做头指针，为了更方便地对链表进行操作，会在单链表的第一个节点前附设一个节点，称为头节点。头节点的数据域可以不存储任何信息，也可以存储如线性表长度等附加信息。
作者想表达的意思应该是无论链表是否为空，头指针都应该存在。 当链表没有头节点时，若想表示一个链表为空表，则需要令头指针为空。
/* 线性表的单链表存储结构 */
typedef struct Node
{
ElemType data;
struct Node *next;
}Node;
typedef struct Node *LinkList; /* 定义LinkList */单链表的存取
/* 初始条件：链式线性表L已存在，1≤i≤ListLength(L) */
/* 操作结果：用e返回L中第i个数据元素的值 */
Status GetElem(LinkList L,int i,ElemType *e)
{
int j;
LinkList p; /* 声明一结点p */
p = L->next; /* 让p指向链表L的第一个结点 */
j = 1; /* j为计数器 */
while (p && j<i) /* p不为空或者计数器j还没有等于i时，循环继续 */
{
p = p->next; /* 让p指向下一个结点 */
++j;
}
if ( !p || j>i )
return ERROR; /* 第i个元素不存在 （i大于元素总个数或小于1）*/
*e = p->data; /* 取第i个元素的数据 */
return OK;
}单链表的插入
/* 初始条件：链式线性表L已存在,1≤i≤ListLength(L)， */
/* 操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1 */
Status ListInsert(LinkList *L,int i,ElemType e)
{
int j;
LinkList p,s;
p = *L; /* p指向单链表的头节点（不是第一个节点） */
j = 1;
while (p && j < i) /* 寻找第i个结点 */
{
p = p->next;
++j;
}
if (!p || j > i)
return ERROR; /* 第i个元素不存在 */
s = (LinkList)malloc(sizeof(Node)); /* 生成新结点(C语言标准函数) */
s->data = e;
s->next = p->next; /* 将p的后继结点赋值给s的后继 */
p->next = s; /* 将s赋值给p的后继 */
return OK;
}单链表的删除
/* 初始条件：链式线性表L已存在，1≤i≤ListLength(L) */
/* 操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1 */
Status ListDelete(LinkList *L,int i,ElemType *e)
{
int j;
LinkList p,q;
p = *L;
j = 1;
while (p->next && j < i) /* 遍历寻找第i个元素 */
{
p = p->next;
++j;
}
if (!(p->next) || j > i)
return ERROR; /* 第i个元素不存在 */
q = p->next;
p->next = q->next; /* 将q的后继赋值给p的后继 */
*e = q->data; /* 将q结点中的数据给e */
free(q); /* 让系统回收此结点，释放内存 */
return OK;
}单链表的整表创建
头插法创建
/* 随机产生n个元素的值，建立带表头结点的单链线性表L（头插法） */
void CreateListHead(LinkList *L, int n)
{
LinkList p;
int i;
srand(time(0)); /* 初始化随机数种子 */
*L = (LinkList)malloc(sizeof(Node));
(*L)->next = NULL; /* 先建立一个带头结点的单链表 */
for (i=0; i<n; i++)
{
p = (LinkList)malloc(sizeof(Node)); /* 生成新结点 */
p->data = rand()%100+1; /* 随机生成100以内的数字 */
p->next = (*L)->next;
(*L)->next = p; /* 插入到表头 */
}
}尾插法创建
/* 随机产生n个元素的值，建立带表头结点的单链线性表L（尾插法） */
void CreateListTail(LinkList *L, int n)
{
LinkList p,r;
int i;
srand(time(0)); /* 初始化随机数种子 */
*L = (LinkList)malloc(sizeof(Node)); /* L为整个线性表 */
r=*L; /* r为指向尾部的结点 */
for (i=0; i<n; i++)
{
p = (Node *)malloc(sizeof(Node)); /* 生成新结点 */
p->data = rand()%100+1; /* 随机生成100以内的数字 */
r->next=p; /* 将表尾终端结点的指针指向新结点 */
r = p; /* 将当前的新结点定义为表尾终端结点 */
}
r->next = NULL; /* 表示当前链表结束 */
}单链表的整表删除
/* 初始条件：链式线性表L已存在。操作结果：将L重置为空表 */
Status ClearList(LinkList *L)
{
LinkList p,q;
p=(*L)->next; /* p指向第一个结点 */
while(p) /* 没到表尾 */
{
q=p->next;
free(p);
p=q;
}
(*L)->next=NULL; /* 头结点指针域为空 */
return OK;
}单链表结构与顺序存储结构的优缺点
①、若线性表需要频繁查找，很少进行插入和删除操作时，宜采用顺序存储结构
②、当线性表中的元素个数变化较大或者根本不知道有多大时，最好用单链表结构
三、静态链表
我们把用数组描述的链表叫做静态链表，这种描述方法还有起名叫做游标实现法。我们让数组的每个元素都是由两个数据域组成，data和cur。也就是说，数组的每个下标都对应一个data和一个cur。数据域data，用来存放数据元素；cur相当于单链表中的next指针，存放该元素的后继在数组中的下标，我们把cur叫做游标。
#define MAXSIZE 1000 /* 存储空间初始分配量 */
/* 线性表的静态链表存储结构 */
typedef struct
{
ElemType data;
int cur; /* 游标(Cursor) ，为0时表示无指向 */
} Component,StaticLinkList[MAXSIZE];
我们对数组第一个和最后一个元素作为特殊元素处理，不存数据。我们通常把未被使用的数组元素称为备用链表，而数组第一个元素，即下标为0的元素的cur就存放备用链表的第一个结点的下标；而数组的最后一个元素的cur则存放第一个有数值的元素下标，相当于链表中头节点作用，当整个链表为空时，则为0。（有些书中把数组的第二个元素作为头节点，实现原理相同，只不过存放位置不同）。
/* 将一维数组space中各分量链成一个备用链表，space[0].cur为头指针，"0"表示空指针 */
Status InitList(StaticLinkList space)
{
int i;
for (i=0; i<MAXSIZE-1; i++)
space[i].cur = i+1;
space[MAXSIZE-1].cur = 0; /* 目前静态链表为空，最后一个元素的cur为0 */
return OK;
}
注意
数据区域的最后一个元素与备用链表区域的最后一个元素游标都是0。当静态链表装满时，首节点（下表为0的节点）的游标为0.
静态链表的插入操作
为了辨明数组中哪些分量未被使用，解决的办法是将所有未被使用过的及已被删除的分量用游标链成一个备用的链表，每当进行插入时，便可以从备用链表上取得第一个结点作为待插入的新结点。
/* 若备用空间链表非空，则返回分配的结点下标，否则返回0 */
int Malloc_SSL(StaticLinkList space)
{
int i = space[0].cur; /* 当前数组第一个元素的cur存的值 */
/* 就是要返回的第一个备用空闲的下标 */
if (space[0]. cur)
space[0]. cur = space[i].cur; /* 由于要拿出一个分量来使用了， */
/* 所以我们就得把它的下一个 */
/* 分量用来做备用 */
return i;
}插入
/*在下标为i的位置上插入元素*/
Status ListInsert(StaticLinkList L,int i,ELemType e){
int j,k,l;
k = MAXSIZE-1; /*k是最后一个元素的下标，即存储空间的大小减1*/
if(i<1||i>Listlength(L)+1){ /*最远只能在当前状态下最后一个元素后面插*/
return ERROR;
}
j = Malloc_SSL(L); /*获得空闲分量的下标*/
if(j){ /*j等于0时说明链表装满了*/
L[j].data=e; /*将数据赋值给此分量的data*/
for(l=1;l<=i-1;l++){ /*找到第i个元素之前的位置*/
k=L[k].cur; /*循环结束后，k等于第i个元素前一个元素的位置*/
}
L[j].cur=L[k].cur; /*把第i个元素之前的cur复制给新元素的cur*/
L[k].cur=j; /* 把新元素的下标赋值给第i个元素之前元素的cur*/
return OK;
}
return ERROR;
}静态链表的删除并回收操作
/* 删除在L中第i个数据元素 */
Status ListDelete(StaticLinkList L, int i)
{
int j, k;
if (i < 1 || i > ListLength(L))
return ERROR;
k = MAXSIZE - 1;
for (j = 1; j <= i - 1; j++)
k = L[k].cur;
j = L[k].cur;
L[k].cur = L[j].cur;
Free_SSL(L, j);
return OK;
}
/* 将下标为k的空闲结点回收到备用链表，如果有新元素来了，优先考虑这里*/
void Free_SSL(StaticLinkList space, int k)
{
space[k].cur = space[0].cur; /* 把第一个元素的cur值赋给要删除的分量cur */
space[0].cur = k; /* 把要删除的分量下标赋值给第一个元素的cur */
}求静态链表中元素个数
/* 初始条件：静态链表L已存在。操作结果：返回L中数据元素个数 */
int ListLength(StaticLinkList L)
{
int j=0;
int i=L[MAXSIZE-1].cur;
while(i)
{
i=L[i].cur;
j++;
}
return j;
}静态链表的优缺点
静态链表是为了让没有指针及引用类型的语言也能够用数组实现链表功能。（所以在C中很不常用）
优点：在插入和删除操作时,只需要修改游标,不需要移动元素,从而改进了在顺序存储结构中的插入和删除操作需要移动大量元素的缺点。
缺点：没有解决连续存储分配带来的表长难以确定的问题；失去了顺序存储结构随机存取的特性
四、循环链表
将单链表中终端结点的指针由空指针改为指向头结点，就使整个单链表形成一个环，这种头尾相接的单链表称为单循环链表，简称循环链表。循环链表解决了如何从链表当中一个结点出发,访问到链表的全部结点的问题。
用指向终端结点的尾指针来表示循环链表（如下图所示）,此时查找开始结点和终端结点都很方便了。
有了尾指针将两个循环链表合并成一个表变得非常简单。
p=rearA->next; /* 保存A表的头结点，即① */
rearA->next=rearB->next->next; /* 将本是指向B表的第一个结点（不是头结点）*/
/* 赋值给reaA->next，即② */
q=rearB->next; /*释放B的头结点*/
rearB->next=p; /* 将原A表的头结点赋值给rearB->next，即③ */
free（q）; /* 释放q */五、双向链表
双向链表是在单链表的每个结点中，再设置一个指向其前驱节点的指针。
/*线性表的双向链表存储结构*/
typedef struct DulNode
{
ElemType data;
struct DuLNode *prior; /*直接前驱指针*/
struct DuLNode *next; /*直接后继指针*/
} DulNode, *DuLinkList;双向链表是单链表中扩展出来的结构，所以它的很多操作是和单链表相同的，比如求长度的ListLength，查找元素的GetElem，获得元素位置的LocateElem等，这些操作都只要涉及一个方向的指针即可，另一指针多了也不能提供什么帮助。
插入结点
将结点s插入到结点p和p->next之间需要下面几步
s - >prior = p; /*把p赋值给s的前驱，如图中①*/
s -> next = p -> next; /*把p->next赋值给s的后继，如图中②*/
p -> next -> prior = s; /*把s赋值给p->next的前驱，如图中③*/
p -> next = s; /*把s赋值给p的后继，如图中④*/删除结点
p->prior->next=p->next; /*把p->next赋值给p->prior的后继，如图中①*/
p->next->prior=p->prior; /*把p->prior赋值给p->next的前驱，如图中②*/
free（p）; /*释放结点*/
