线性表的链式数据结构

线性表的链式存储结构

• 前面我们讲的线性表的顺序存储结构，它最大的缺点就是插入和删除时需要移动大量的元素，这显然就需要耗费时间。
• 那我们能不能针对这个缺陷或者说遗憾提出解决的方法呢？要解决这个问题，我们就得考虑一下导致这个问题的原因！
• 原因就在于相邻两个元素的存储位置也具有邻居关系，它们在内存中的位置是紧挨着的，中间没有间隙，当然就无法快速插入和删除。

线性表链式存储结构定义

• 线性表的链式存储结构的特点是用一组任意的存储单元存储线性表的数据元素，这组存储单元可以存在内存中未被占用的任意位置。
• 比起顺序存储结构每一个数据元素只需要存储一个位置就可以了。现在链式存储结构中，除了要存储数据元素信息外，还要存储它的后继元素的存储地址（指针）。
• 也就是说除了存储其自身的信息外，还需要存储一个其直接后继的存储位置的信息。
• 我们把存储数据元素信息的域称为数据域，把存储直接后继位置的域称为指针域。指针域中存储的信息称为指针或链。这两部分信息组成数据元素称为存储映像，称为结点（Node）。
• n个结点（Node）链接成一个链表，即为线性表（a1,a2,a2，……,an）的链式存储结构。
• 因为此链表的每个结点中只包含一个指针域，所以叫做单链表。

单链表

• 对于线性表来说，总得有个头有个尾，链表也不例外。我们把链表中的第一个结点的存储位置叫做头指针，最后一个结点指针为空（NULL）（^）。

头指针于头结点的异同

• 问题：既然头结点的数据域不存储任何信息，那么头指针和头结点又有何异同呢？
  • 头指针
    • 头指针是指链表指向第一个结点的指针，若链表有头结点，则是指向头结点的指针。
    • 头指针具有标识作用，所以常用头指针冠以链表的名字（指针变量的名字）。
    • 无论链表是否为空，头指针均不为空。
    • 头指针是链表的必要元素。
  • 头结点
    • 头结点是为了操作的统一和方便而设立的，放在第一个元素的结点之前，其数据域一般无意义（但也可以用来存放链表的长度）。
    • 有了头结点，对在第一个元素结点前插入结点和删除第一结点起操作与其它结点的操作就统一了。
    • 头结点不一定是链表的必须要素。

单链表存储结构

• 在c语言中可以用结构指针来描述单链表：

  typedef struct Node
  {
  	ElemType data;	//数据域
  	struc Node * Next;	//指针域
  }Node;
  typedef struct Node * LinkList;
  

• 假设p是指向线性表第i个元素的指针，则该结点ai的数据域我们可以用p->data的值是一个数据元素，结点ai的指针域可以用p->next来表示，p->next的值是一个指针。

• 那么p->next指向谁呢？当然是指向第i+1个元素！也就是指向ai+1的指针。

  • 问题：如果p->data = ai,那么p->next->data = ?
  • 答:p->next->data = a(i+1)

单链表的读取

• 在线性表的顺序存储结构中，我们要计算任意一个元素的存储位置是很容易的。

• 但在单链表中，由于第i个元素到底在哪？我们压根儿没办法一开始就知道，必须得从第一个结点开始挨个儿找。

• 因此，对于单链表实现获取第i个元素的数据的操作GetElem，在算法上相对要麻烦一些。

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

  • 声明一个结点p指向链表第一个结点，初始化j从1开始；
    • 当j<i时，就遍历链表，让p的指针向后移动，不断指向下一个结点，j+1;
      * 若到链表末尾p为空，则说明第i个元素不存在；
  • 若查找成功，返回结点p的数据。

• 代码实现：

  /*初始条件：顺序线性表L已经存在，1<=i<=L->length*/
  /*操作结果：用e返回L中第i个数据元素的值*/
  
  Status GetElem( LinkList L , int i , ElemType * e){
  	int j;
  	LinkList p;
  	
  	p = L->next;	//将头结点后面的第一个带数据的结点赋值给临时变量p
  	j = 1;
  	
  	while(p && j<i){
  		p = p->next;
  		++j;
  	}
  	
  	if(!p || j>i){
  		return ERROR;
  	}
  	
  	*e = p->data;
  	return OK;
  }
  

• 说白了，就是从头开始找，直到第i个元素为止。

• 由于这个算法的时间复杂度取决于i的位置，当i=1时，则不需要遍历，而i=n时则遍历n-1次才可以。因此最坏情况的时间复杂度为O(n)。

• 由于单链表的结构中没有定义表长，所以不能实现知道要循环多少次，因此也就不方便使用for来控制循环。

• 其核心思想叫做“工作指针后移”，这其实也是很多算法的常用技术。

单链表的插入

• 假设存储元素e的结点为s，要实现结点p、p->next和s之间逻辑关系的变化。

• 思考过后发觉，根本用不着惊动其他结点，只需要让s->next和p->next的指针做一点改变。

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

• 思考：这两句代码的顺序可不可以交换过来？

  • 答：不能，如果先执行p->next的话会被覆盖为s的地址，那么s->next = p->next其实就等于s->next = s了。
  • 所以这两句是无论如何不能弄反的，这点初学者一定要注意。

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

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

• 代码实现：

  /*初始条件：顺序线性表L已经存在，1<=i<=L->length*/
  /*操作结果：在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;
  	}
  	
  	s = (LinkList) malloc(sizeof(Node));
  	s->data = e;
  	
  	s->next = p->next;
  	p->next = s;
  	
  	return OK;
  }
  

单链表的删除

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

• 那我们所要做的，实际上就是一步：

  • 可以这样：p->next = p->next ->next;
  • 也可以这样：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<L->length*/
  /*操作结果：删除L的第i个数据元素，并用e返回其值，L的长度-1*/
  
  Status ListDelet(LinkList *L , int i , ElemType * e){
  
  	int j;
  	LinkList p,q;
  	
  	p = L->next;	//将链表的第二个结点赋值给临时变量p
  	j = 1;
  	
  	while(p && j<i){	//将链表遍历到第i-1个结点的位置，p->next 就是要删除的数据结点的地址
  		p = p->next;
  		++j;
  	}
  	
  	if(!(p->next) || j<i){
  		return ERROR;
  	}
  	
  	q = p->next;	//将要删除的地址赋值给临时指针q
  	p->next = q->next;	
  	
  	*e = q->data;
  	free(q);
  	
  	return OK;
  }
  

效率

• 我们发现无论是单链表插入还是删除算法，它们其实都是由两个部分组成：第一部分就是遍历查找第i个元素，第二部分就是实现插入和删除元素。
• 从整个算法来说,我们很容易可以推出它们的时间复杂度都是O(n)。
• 再详细点分析:如果在我们不知道第i个元素的指针位置，单链表数据结构在插入和删除操作上，于线性表的顺序存储结构是没有太大优势的。
• 但如果，我们希望从第i个位置开始，插入连续10个元素，对于顺序存储结构意味着，每一部次插入都需要移动n-1个位置，所以每次都是O(n)。
• 而单链表，我们只需要在第一次时，找到第i个位置的指针，此时为O(n),接下来只是简单地通过赋值移动指针而已，时间复杂度都是O(1)。
• 显然，对于插入或者删除数据频繁的操作，单链表的效率优势就是越时明显。

单链表的整体创建

• 对于顺序存储结构的线性表的整表创建，我们可以用数组的初始化来直观理解。
• 而单链表和顺序存储结构就不一样了，他不像顺序存储结构数据这么集中，它的数据可以时分散在内存各个角落的，他的增长也是动态的。
• 对于每个链表来说，它所占用空间的大小和位置时不需要预先分配划定的，可以根据系统的情况和实际的需求即时生成。
• 创建单链表的过程时一个动态生成链表的过程，从”空表“初始状态起，依次建立各元素结点并逐个插入链表。
• 所以单链表整表创建的算法思路如下：
  • 声明一结点p和计算器变量i；
  • 初始化一空链表L；
  • 让L的头结点的指针指向NULL,即建立一带头结点的单链表；
  • 循环实现后继结点的赋值和插入。

头插法建立单链表

• 头结点从一个空表开始，生成新结点，读取数据存放到新结点的数据域中，然后将新结点插入到当前链表的表头上，直到结束为止。

• 简单来说，就是把新加进的元素放在表后的第一个位置：

  • 先让新结点的next指向头结点之后
  • 然后让表头的next指向新结点

• 代码实现：

  /*头插法建立链表示例*/
  
  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;	//向新的结点中的数据域赋值（随机数）
  		p->next = (*L)->next;
  		(*L)->next = p;
  	}
  	
  }
  

不理解的话，可以画一个草图

尾插法建立单链表

• 头插法建立链表虽然算法简单，但生成的链表中结点的次序和输入的顺序相反。

• 把新结点都插入到最后，这种的算法称为尾插法。

• 代码实现：

  /*尾插法建立单链表演示*/
  
  void CreateListTail(LinkList *L,int n){
  	LinkList p,r;
  	int i;
  	
  	srand(time(0));
  	*L = (LinkList)malloc(sizeof(Node));
  	r = *L;
  	
  	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的操作；

• 代码实现：

  Status ClearList(LinkList *L){
  
  	LinkList p,q;
  	
  	p = (*L)->next;
  	
  	wilie(p){
  		q = p->next;
  		free(p);
  		p = q;
  	}
  	
  	return OK;
  }
  

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

• 我们分别从存储分配方式、时间性能、空间性能三个方面来做对比。

• 存储分配方式：

  • 顺序存储结构用一段连续的存储单元依次存储线性表的数据元素。
  • 单链表采用链式存储结构，用一组任意的存储单元存放线性表的元素。

• 时间性能：

  • 查找
    • 顺序存储结构O(1)
    • 单链表O（n）
  • 插入和删除
    • 顺序存储结构需要平均移动表长一半的元素，时间为O(n)
    • 单链表在计算出某位置的指针后，插入和删除时间仅为O(1)

• 空间性能：

  • 顺序存储结构需要预分配存储空间，分大了，容易造成空间浪费，分小了，容易发生溢出。
  • 单链表不需要分配存储空间，只要有就可以分配，元素个数也不受限制。

• 结论：

  • 若线性表需要频繁查找，很少进行插入和删除操作时，宜采用顺序存储结构。

• 比如说游戏开发中，对于用户注册的个人信息，除了注册时插入数据外，绝大多数情况都时读取，所以应该考虑用顺序存储结构。

• 而游戏中的玩家的武器或者装备列表，随着玩家的游戏过程中，可能会随时增加或删除，此时再用顺序存储就不太合适了，单链表结构就可以大展拳脚了。

• 当线性表中的元素个数变化较大或者根本不知道有多大时，最好用单链表结构，这样可以不需要考虑存储空间的大小问题。

• 总之，线性表的顺序存储结构和单链表结构各有其优缺点，不能简单的说哪个好，哪个不好，需要根据实际情况，来综合平衡采用哪种数据结构更能满足和达到需求和性能。