大话数据结构三（线性表的链式存储）

3.6.1 线性表链式存储结构定义

线性表的链式存储结构的特点是用一组任意的存储单元存储线性表的数据元素，这组存储单元可以是连续的，也可以是不连续的。这就意味着，这些数据元素可以存在内存未被占用的任意位置

以前在顺序结构中，每个数据元素只需要存数据元素信息就可以了。
现在链式结构中，除了要存数据元素信息外，还要存储它后继元素的存储地址

为了表示每个数据元素ai与其直接后继数据元素ai+1之间的逻辑关系，对数据元素ai来说，除了存储其本身的信息之外，还需存储一个指示其直接后继的信息（即直接后继的存储位置）。

我们把存储数据元素信息的域称为数据域，把存储直接后继位置的域称为指针域

指针域存储的信息称做指针或域。这两部分信息组成数据元素ai的存储映像，称为结点

n个结点（ai的存储映像）链结成一个链表，即为线性表(a1,a2,…,an)的链式存储结构，因为此链表的每个结点中只包含一个指针域，所以叫单链表

链表中第一个结点的存储位置叫做头指针，线性链表的最后一个结点指针称为“空”或nul

为了方便对链表进行管理，会在单链表的第一个结点前附设一个结点，称为头结点，头结点不存储任何信息，一般存储线性表长度等公共数据

3.6.2 头指针与头结点的异同

头指针	头结点
头指针是指链表指向第一个结点的指针，若链表有头结点，则是指向头结点的指针	头结点是为了操作的统一和方便而设立的，放在第一元素的结点之前，其数据域一般无意义
头指针具有标识作用，所以常用头指针冠以链表的名字	有了头结点，对在第一元素结点前插入结点和删除第一结点，其操作与其他结点的操作就统一了
无论链表是否为空，头指针均不为空。头指针是1链表的必要元素	头结点不一定是链表必须要素

3.6.3 线性表链式存储结构代码描述

结点由存放数据元素的数据域和存放后继结点地址的指针域组成

/*线性表的单链表存储结构*/
typedef struct Node
{
    ElemType data;
    struct Node *next;
}Node;
typedef struct Node *LinkList; /* 定义LinkList */

3.7、单链表的读取

获得链表第i个数据的算法思路：

1. 声明一个指针p指向链表第一个结点，初始化j从1开始
2. 当j<i时，就遍历链表，让p的指针向后移动，不断指向下一个结点，j累加1
3. 若到链表末尾p为空，则说明第i个结点不存在
4. 否则查找成功，返回结点p的数据
   
   

* 初始条件：链式线性表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个元素不存在 */
	*e = p->data;   /*  取第i个元素的数据 */
	return OK;
}

说白了，就是从头开始找，直到第i个结点为止。由于这个算法的时间复杂度取决于i的位置，当i=1时，则不需遍历，第一个就取出数据了，而当i=n时则遍历n-1次才可以

3.8、 单链表的插入和删除

3.8.1 单链表的插入

假设存储元素e的结点为s，要实现结点p、p->next和s
之间逻辑关系的变化，只需将结点s插入到结点p和p->next之间即可

s->next=p->next;
p->next=s;

也就是说让p的后继结点改成s的后继结点，再把结点s变成p的后继结点


单链表第i个数据插入结点的算法思路：

1. 声明一指针p指向链表头结点，初始化j从1开始
2. 当j<i时，就遍历链表，让p的指针向后移动，不断指向下一节点，j累加1；
3. 若到链表末尾p为空，则说明第i个结点不存在
4. 否则查找成功，在系统中生成一个空结点s
5. 将数据元素e赋值给s->data
6. 单链表的插入标准语句s->next=p->next;p->next=s;
7. 返回成功

/* 初始条件：链式线性表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;   
	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;
}

3.8.2 单链表的删除

设存储元素ai的结点为q，要实现将结点q删除单链表的操作，其实就是将它的前继结点的指针绕过，指向它的后继结点即可。

q = p->next;
p->next = q->next;

也就是说把p的后继结点改成p的后继的后继结点

单链表第i个数据删除结点的算法思路：

1. 声明一指针指向链表头指针，初始化j从1开始
2. 当j<i时，就遍历链表，让p的指针向后移动，不断指向下一个结点，j累加1
3. 若到链表末尾p为空，则说明第i个结点不存在
4. 否则查找成功，将欲删除的结点p->next赋值给q
5. 单链表的删除标准语句p->next=q->next
6. 将q结点中的数据赋值给e，作为返回
7. 释放q结点
8. 返回成功

/* 初始条件：链式线性表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;
}

分析一下单链表的插入和删除算法，不难发现，它们其实都是由两部分组成：
1：遍历查找第i个结点
2：插入和删除结点

对于插入和删除数据越频繁的操作，单链表的效率优势就越是明显

3.9、 单链表的整表创建

单链表整表创建的算法思路：

1. 声明一指针p和计数器变量i
2. 初始化一空链表L
3. 让L的头结点的指针指向NULL，即建立一个带头结点的单链表
4. 循环：
   1）生成一新结点赋值给p；
   2）随机生成一数字赋值给p的数据域p->data;
   3）将p插入到头结点与前一新结点之间

/*  随机产生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与r的关系，L是指整个单链表，而r是指向尾结点的变量，r会随着循环不断地变化结点，而L则是随着循环增长为一个多结点的链表

3.10、单链表的整表删除

单链表整表删除的算法思路如下：

1. 声明一结点q和p
2. 将第一个结点赋值给p
3. 循环
   1）将下一结点赋值给q
   2）释放p
   3）将q赋值给p

/* 初始条件：链式线性表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;
}

3.11、单链表结构与顺序存储结构优缺点

存储分配方式	时间性能	空间性能
顺序存储结构用一段连续的存储单元依次存储线性表的数据元素	查找: 1）顺序存储结构0（1） 2）单链表0（n）	顺序存储结构需要预先分配空间，分大了浪费，分小了易发生上溢
单链表采用链式存储结构，用一组任意的存储单元存放线性表的元素	删除和插入： 1）顺序存储结构需要平均移动表长一半的元素，时间为0（n） 2）单链表在找出某位置的指针后，插入和删除时间仅为0（1）	单链表不需要分配存储空间，只要有就可以分配，元素个数也不受限制

3.12、 静态链表

我们让数组的元素都是由两个数据域组成，data和cur。数组的每个下标都对应一个data和一个cur。数据域data，用来存放数据元素，也就是通常我们要处理的数据；而cur相当于单链表中的next指针，存放该元素的后继在数组中的下标，我们把cur叫做游标

把数据描述的链表称为静态链表

/* 线性表的静态链表存储结构 */
typedef struct 
{
    ElemType data;
    int cur;  /* 游标(Cursor) ，为0时表示无指向 */
} Component,StaticLinkList[MAXSIZE];