单链表

一，链式存储结构的一些基本概念
在链式结构中，除了要存数据元素之外，还要存储它的后继元素的存储地址。
为了表示每个数据元素ai与其后继数据元素ai+1之间的逻辑关系，对于ai来说，除了存储其本身的信息之外，还需要存储一个指示其直接后继的信息。存储数据元素信息的域叫数据域，存储直接后继位置的域叫指针域，指针域中存储的信息称做指针或链接，这两部分信息组成数据元素ai的存储映像，称为结点（Node）。
n个结点链接成一个链表，即为线性表的链式存储结构。因为此链表的每个结点中只包含一个指针域，所以叫做单链表。

链表中第一个结点的存储位置叫做头指针，最后一个结点指针为空。

有时为了方便，会在单链表的第一个结点前附设一个结点，称为头结点。数据域不存储任何信息，也可以存储线性表的长度等附加信息，头结点的指针域指向第一个结点的指针。

空链表

C语言用结构指针描述单链表

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

假设p是指向线性表第i个元素的指针，则数据域可表示如下图

二，单链表的读取
获取链表第i个数据的算法思路：

• 声明一个结点p指向链表第一个结点，初始化j从1开始；
• 当j < i 时，就遍历链表，让p的指针向后移动，不断指向下一结点，j累加1；
• 若到链表末尾p为空，则说明第i个元素不存在
• 否则查找成功，返回结点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;
	  	++j;
	  }
	  if（！p || j>i）
	  	return ERROR;
	  *e = p->data;
	  return OK;                                                                                                                                                                       
}

时间复杂度取决于i的位置，i=1，不需要遍历，i=n，遍历n-1次。平均就是n/2次，所以时间复杂度是O(n)。
（由于单链表没有定义表长，不方便用for来控制循环，其核心思想就是“工作指针后移”）

三，单链表的插入和删除
插入

重点：

s->next = p->next;
p->next = s;//注意顺序不要颠倒，不能先改变p指针的值

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

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

实现代码算法如下

/*初始条件：顺序线性表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 )
	{
		p = p->next;
		++j;
	}
	if ( !p || j >1)
		return ERROR;
	s = (LinkLIst) malloc (sizeof(Node)); //生成新结点
	s->data = e;
	s->next = p->next; //将p的后继结点赋值给s的后继
	p->next = s;
	return OK;
}

删除

重点：

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

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

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

实现代码算法如下：

/*初始条件：顺序线性表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) //因为是删除元素，所以要确认p->next是不是空
	{
		p = p->next;
		++j;
	}
	if ( !(p->next) || j > 1)
		return ERROR;
	q = p->next;
	p->next = q->next;
	*e = q->data;
	free(q);
	return OK;
}

线性表的链式存储结构插入和删除的时间复杂度都是O(n)，和顺序存储结构一样。但是，如果是在某一个位置 i 插入10个元素，对于顺序存储结构。每一个插入都要移动 n-i 个元素，但是单链表，只需要在第一次找到第 i 个位置的指针，接下来只是简单地通过赋值移动指针而已，时间复杂度都是O(1)。
对于插入或删除数据越频繁的操作，单链表的效率优势就越明显。

四，单链表的整表创建
对于链表来说，它所占用空间的大小和位置是不需要预先分配划定的，可以根据系统的情况和实际的需要即时生成。
所以创建单链表的过程就是一个动态生成链表的过程，即从“空表”的初始状态起，依次建立各元素结点，并逐个插入链表。

1，头插法
让新结点始终在第一的位置

图解：

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

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

2，尾插法
每次新结点都插在终端结点的后面

实现代码：

/*随机产生n个元素的值，建立带表头结点的单链线性表L（尾插法）*/
void CreateListTail ( LinkList *L, int n )
{
	LInkList p,r;
	int i;
	srand( time (0)); //初始化随机数种子
	*L = (LinkLIst) malloc (sizeof(Node)); //为整个线性表
	r = *L; //r为指向尾部的结点
	for (i=0; i<n; i++)
	{
		p = (Node *) malloc (sizeof(Node)); //生成新结点
		p->data = rand()%100 + 1;
		r->next = p;
		r = p; //将当前的新结点定义为表尾终端结点
	}
	r->next = null;
}

五，单链表的整表删除

算法思路：

• 声明一结点p和q
• 将第一个结点赋值给p
• 循环：将下一结点赋值给q =>释放p =>将q赋值给p

实现代码：

/*初始条件：单链线性表L已存在，操作结果：将L重置为空表*/
Status ClearList (LinkList *L)
{
	LinkList p,q;
	p=(*L)->next;
	while(p)
	{
		q = p->next;
		free(p);
		p = q;
	}
	(*L)->next = null; //头结点指针域为空
	return OK;
}

六，顺序存储结构与单链表结构的优缺点
1，存储分配方式
顺序存储结构用一段连续的存储单元依次存储线性表的数据元素；单链表采用链式存储结构，用一组任意的存储单元存放线性表的元素
2，时间性能
查找：顺序存储结构O(1)；单链表O(n)
插入和删除：顺序存储结构O(n)；单链表在找出某位置的指针后，插入和删除时间仅为O(1)
3，空间性能
顺序存储结构需要预分配存储空间，分大了，浪费，分小了容易发生上溢；单链表不需要分配存储空间，只要有就可以分配，元素个数也不受限制

综上有一些经验性结论：
简单考虑游戏开发中的用户注册，除了注册时插入数据，绝大多数都是读取，所以用顺序存储结构更有效率；而游戏中的玩家的武器或者装备列表，随着玩家的游戏过程中，可能随时增加或者删除，此时更适合用单链表。
此外，当线性表中的元素个数变化较大，或者根本不知道多大的时候，最好用单链表；如果已知长度，用顺序存储结构更高效。