线性表链式存储结构之单链表

线性表链式存储结构之单链表-五分钟学算法

线性表的链式存储结构的特点就是用一组任意的存储单元存储线性表的数据元素，这组存储单元可以在内存中未被占用的任意位置。比起顺序存储结构每个元素只需要存储一个位置就可以了。现在链式存储结构中，除了要存储数据信息外，还要存储它的后继元素的存储地址（指针）。也就是说除了存储其本身的信息外，还需要存储一个指示其直接后继的存储位置的信息。来几个概念：把存储数据元素信息的域称为数据域，把存储直接后继位置的域称为指针域。指针域中存储的信息称为指针或链。这两部分信息组成数据元素称为存储映像，称为结点（Node).01.
单链表因为此类链表的每个结点中只包含一个指针域，所以叫做单链表。对于线性表来说，总得有个头有个尾，链表也不例外。我们把链表中的第一个结点的存储位置叫做头指针，最后一个结点指针为空（null）。头指针与头节点的异同：

• 头节点的数据域一般不存储任何信息，谁叫它是第一个呢，有这个特权。

• 头指针 是指向链表第一个结点的指针，若链表有头节点，则是指向头结点的指针。

• 头指针具有标识作用，所以常用的头指针冠以链表的名字（指针变量的名字）。

• 无论链表是否为空，头指针均不为空

• 头指针是链表的必要元素。

• 头结点是为了操作的统一和方便而设立的，放在第一个元素的结点之前，其数据域一般无意义（但也可以用来存放链表的长度）。

• 有了头结点，对在第一个元素结点前插入结点和删除第一结点起操作与其他节点的操作就统一了。

• 头结点不一定是链表的必须要素。

单链表图例：

空链表图例：

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

02.

单链表常见操作

单链表的读取

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

/*GetElem.c*/
Status GetElem(LinkList L, int i, ElemType *e) {
    int j;
    LinkList p;
    
    p = L->next;
    j = 1;
    
    while( p && j < i){
        p = p->next;
        j++;
    }
    
    if( !p){
        return ERROR;
    }
    
    *e = p->data;
    
    return OK;
}

单链表的读取，说白了，就是从头结点开始找呀找，直到第 i 个元素为止。
由于这个算法的时间复杂度取决于 i 的位置，当 i = 1 时， 则不需要遍历，而 i = n 时则遍历n-1次才可以。因此最坏情况的时间复杂度为O(n).由于单链表的结构中没有定义表长，所以不能实现知道循环多少次，因此也就不方便使用for来控制循环，而选择while语句。其核心思想叫做 “工作指针后移”，这是很多算法的常用技术。

单链表的插入

假设存储元素 e 的结点为 s，要将结点 s 插入结点p、p->next 之间的逻辑图示：

一定要注意单链表插入元素时指针的修改顺序奥！

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

• 声明一个结点p指向链表头结点，初始化 j 从 1 开始

• 当 j < 1 时，就遍历链表，让 p 的指针向后移动，不断指向下一个结点， j 累加 1；

• 若到链表末尾 p 为空，则说明第 i 个元素不存在；

• 否则查找成功，在系统中生成一个空结点 s；

• 将数据元素e 赋值给s->data

• 执行插入语句，并返回成功

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)); /*生成一个新的结点*/
    s->data = e; /*将e赋值给结点s的数据域*/
    
    s->next = p->next; /*插入步骤1*/
    p->next = s; /*插入步骤2*/
    
    return OK;
    
}

单链表的删除

要实现第二个结点的删除操作，其实就是将它的前继结点的指针绕过第二个节点，直接指向第二个结点的后继结点即可。

Status ListDelete(LinkList *L, int i, ElemType *e){
    int j;
    LinkList p,q;
    p = *L;
    j = 1;
    
    while( p->next && j<i)
    {
        p = p->next;
        ++j;
    }
    if( !(p->next) || j>i )
    {
        return ERROR;
    }
    
    q = p->next;
    p->next = q->next; /*这两句相当于p->next = p->next->next;*/
    
    *e = q->data;
    free(q);
    
    return OK;
}

对于插入和删除数据越频繁的操作，单链表相比顺序存储结构而言，效率优势就越明显。03.

单链表的创建

单链表的整表创建

• 对于顺序存储结构的线性表的整表创建，我们可以用数组的初始化来直观理解。

• 而单链表和顺序存储结构就不一样了，它不像顺序存储结构数据这么集中，它的数据可以分散在内存的各个角落，它的增长也是动态的。

• 对于每个链表来说，它所占用空间的大小和位置是不需要预先分配划定的，可以根据系统的情况和实际的需求即时生成。

• 人生就要追求和单链表一样，灵活应变！

创建单链表的过程是一个动态生成链表的过程，从“空表” 的初始状态起，依次建立各元素结点并逐个插入链表。单链表整表创建的算法思路：

• 声明一个结点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; //生成1到100之间的随机数
        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; //r初始化指向尾部结点
    
    for( i=0; i<n; i++){
        p = (Node *)malloc(sizeof(Node));
        p->data = rand()%100+1;
        r->next = p;
        r = p;
    }
}

单链表的整表删除

当我们不打算使用单链表时，需要将其销毁。其实就是在内存中将它释放掉，以便留出空间给其他程序或软件使用。

单链表整表删除算法思路：

• 声明结点p和q;

• 将第一个结点赋值给p，下一个结点赋值给q；

• 循环执行失望p和q赋值给p的操作；

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;
}

注意观察上面代码中while循环体内，可能觉着q变量没有存在的必要，只需要在循环体内直接写free(p)；p = p->next; 但这样做是不行滴！要知道p是一个结点，它除了数据域，还有指针域。当我们做free(p)；的时候，其实是对它整个结点进行删除和内存释放的工作，也就是把p的指针域（指向下一个结点）也给删除了，所以需要变量q来保存p的下一个结点。

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

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

1. 存储分配方式：

   • 顺序存储结构用一段连续的存储单元依次存储线性表的数据元素。

   • 单链表采用链式存储结构，用一组任意的存储单元存放线性表的元素。

2. 时间性能：

   • 顺序存储结构需要平均移动表长一半的元素，时间为O(n)

   • 单链表在计算出某位置的指针后，插入和删除时间仅为O(1)

3. • 顺序存储结构O(1)

   • 单链表O(n)

4. • 插入和删除

5. 空间性能：

   • 顺序存储结构需要预分配存储空间，分大了，容易造成空间浪费，分小了，容易发生溢出。

   • 单链表不需要分配存储空间，只要有就可以分配，元素个数也不受限制。

综上所述，我们得出一些经验性的结论：

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

• 若需要频繁插入和删除时，宜采用单链表结构

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

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

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

• 而如果事先知道线性表的大致长度，比如一年12个月，一周就是星期一至星期天共七天，这种用顺序存储结构效率会更高。

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

END

作者：景禹，一个追求极致的共享主义者，想带你一起拥有更美好的生活，化作你的一把伞。