数据结构与算法（六）线性表的链式存储结构

Felix Du

于 2024-10-03 16:51:43 发布

阅读量1.3k

点赞数 40

分类专栏：数据结构与算法（c语言实例）文章标签：数据结构算法程序人生学习

本文链接：https://blog.csdn.net/less_duuuzx/article/details/142693354

版权

数据结构与算法（c语言实例）专栏收录该内容

9 篇文章 1 订阅

订阅专栏

前言

先前由于篇幅原因，该博客拆解为两部分“线性表的链式存储结构-1”与“线性表的链式存储结构-2”更新，为方便各位读者阅读与查询，将原本两篇博客合并在此，并收纳如专栏“数据结构与算法（C语言实例）”中，欢迎广大读者批评指正！

专栏地址：数据结构与算法（c语言实例）_Felix Du的博客-CSDN博客

一、链式存储结构的引入

前面我们讲的线性表的顺序存储结构，他最大的特点就是插入和删除时需要移动大量元素，这显然就需要耗费时间。那么我们能不能针对这个缺陷来提出解决问题的方法呢？要来解决这个问题，我们就得考虑一下导致这个问题的原因是什么：为什么当插入和删除时，就要移动大量的元素？

原因就在于相邻两元素的存储位置也具有邻居关系，它们在内存中的位置是紧挨着的，中间没有间隔，当然就无法快速插入和删除。那么我们在相邻元素间留出一点空间，这样就能解决了吗？

但是显然，无论你留下多少个，都是不合适的，太少的话无法插入较长的数据，太多的话又占用太大的空间。反正我们在相邻元素间留多少空间都是有可能不够的，那么不如干脆不要考虑相邻位置这个问题了。哪里有空位我们就放在哪，利用指针对元素进行定位。每个元素多用一个位置来存放指向下一个元素的位置的指针。这样子从第一个元素可以找到第二个元素，第二个元素可以找到第三个元素，依次类推，所有的元素我们就都能通过遍历来找到了，这就是线性表的链式存储结构。

二、链式存储结构的定义

线性表的链式存储结构的特点是用一组任意的存储单元存储线性表的数据元素，这组存储单元可以存在内存中未被占用的任意位置。

比起顺序存储结构每个数据元素只需要存储一个位置就可以的情况，现在链式存储结构中，除了要存储数据元素信息外，还要存储它的后继元素的存储地址（指针）。也就是说链式存储需要两个位置来存放元素，一个是存放他本身，一个是存放他下一个数据元素的指针地址。

我们把存储数据元素信息的域（所谓的域，其实就是一个地方而已）称为数据域，把存储直接后继位置的域称为指针域。指针域中存储的信息称为指针或链。这两部分信息组成数据元素称为存储映像，称为结点（Node）。

n个结点链接成一个链表，即为线性表（ $a_1,a_2,a_3...,a_n$ )的链式存储结构。因为此链表的每个结点中只包含一个指针域，所以叫做单链表。

三、单链表

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

四、头指针和头节点的异同

上文我们提到了，头结点的数据域一般不存储任何信息，这是它作为第一个结点的特性。就像下图，你只需要拿个小旗子就可以了（^_^)。

那么这个时候就会有疑惑了，既然头结点的数据域不存储任何信息，那么头指针和头结点又有什么异同呢？

1、头指针

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

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

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

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

2、头结点

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

-有了头结点，对在第一个元素结点前插入结点和删除第一结点起操作域其他结点从操作就统一了。

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

我们在C语言中可以用结构指针来描述单链表

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

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

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

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

一道题辅助理解：

如果p—>data= $a_i$ ，那么p—>next—>data=?

答案：p—>next—>data= $a_i+1$

五、单链表的读取

在线性表的顺序存储结构中，我们要计算任意一个元素的存储位置是很容易的。但在单链表中，由于第i个元素到底在哪？我们无法一开始就知道，所以必须从第一个结点开始挨个查找。

因此，对于单链表实现获取第i个元素的数据的操作GetElem，在算法上相对要麻烦一些，那么我们要来获取链表第i个数据的算法思路如下：

-声明一个结点p指向链表第一个结点，初始化j从1开始；

-当j<i时，就遍历链表，让p的指针向后移动，不断指向一下结点，j+1；

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

-否则查找成功，返回结点p的数据。

有了以上的思路提示，我们就可以通过以下代码来实现：

Status GetElem（LinkList L，int i，ElemType *e）
{
    int j;
    LinkList p;

    p=L—>next;
    j=1;

    while(p && j<1)
    {
        p=p—>next;
        ++j;
    }
    if(!p ||j>i)
    {
        return ERROR;
    }
    *e = p —>data;
    return 1;
}

说白了，就是从头开始找，直到第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；

那么，我们仔细思考，如果先执行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;

-单链表的插入刚才两个标准语句；

-返回成功。

Status ListInsert(LinkList *L,int i,ElemType e)
{
    int j;
    LinkList p,s;
    
    p=*L;
    j = 1;
    
    while(p && j<1)//用于寻找第i个结点
    {
        p = p—> next;
        j++;
    }
    if( !p || j>1)
    {
        return ERROR;
    }

    S = (LinkList)malloc(sizeof(Node));
    s —>data = e；
    
    s —> next = p —> next;
    p —> next =s;
    return 1;
}

七、单链表的删除

我们通过一张图来看单链表的删除操作

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

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

可以是这样：p —> next = p —> next—> next;

也可以是：q = p—> next；p —> next = q—> next；

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

-声明结点p指向链表第一个结点，初始化j=1；

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

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

-否则查找成功，将欲删除结点p —> next赋值给q；

-单链表的删除标准语句 p —> next = q—> next；

-将q结点中的数据赋值给e，作为返回；

-释放q结点。

代码如下：

Status LinkDelete（LinkList *L，int i，ElemType *e）
{
    int j;
    LinkList p,q;
    
    p = *L;
    j = 1;
    
    while( p—>next && j<1)
    {
        p = p—>next;
        ++j;
    }
`   
    if(!(p—>next） || j>1)
    {
        return ERROR;
    }
    
    q = p—>next;
    p —> next = q—>next;
    
    *e = q—>data;
    free(q);
    
    return 1;
}

八、链表与顺序存储结构的效率比较

我们发现，无论是单链表插入还是删除算法，它们其实都是由两个部分组成：第一部分就是遍历查找第i个元素，第二部分就是实现插入和删除元素。

从整个算法来说，我们很容易可以推出它们的时间复杂度都是O(n）

再详细点分析：如果在我们不知道第i个元素的指针位置，单链表数据结构在插入和删除操作上，与线性表的顺序存储结构是没有太大优势的。但如果我们希望从第i个位置开始，插入连续10个元素，对于顺序存储结构意味着每次插入都需要移动n-i个位置，所以每次都是O(n）

而单链表，我们只需要在第一次，找到第i个位置的指针，此时为O(n），接下来只是简单地通过赋值移动指针而已，时间复杂度都是O(1)

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

九、单链表的整表创建

1、单链表的创建思路

对于顺序存储结构的线性表的整表创建，我们可以用数组的初始化来直观理解。而单链表和顺序存储结构就不一样了，它不像顺序存储结构数据那么集中，它的数据可以是分散在内存各个角落的，他的增长也是动态的。而对于每个链表来说，它所占用空间的大小和位置是不需要预先分配划定的，可以根据系统的情况和实际的需求即时生成，相对于顺序结构来说，单链表更加灵活多变。

创建单链表的过程是一个动态生成链表的过程，我们要从“空表”的初始状态起，依次建立个元素结点并逐个插入链表。

所以单链表整表创建的算法思路如下：

-声明一结点p和计数器变量i；

-初始化一空链表L；

-让L的头结点的指针指向NULL，即建立一个带头结点的单链表。

-循环实现后继结点的赋值和插入；

2、头插法建立单链表

头插法从一个空表开始，生成新结点，读取数据存放到新结点的数据域中，然后将新结点擦汗如到当前链表的表头上（表的头部就是head指针指向的位置），直到结束位置。

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

-先让新结点的next指向头结点之后；

-然后让表头的next指向新结点

举个现实中的例子，就是插队嘛，始终让新结点插在第一的位置。代码如下:

void CreatListHead(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;
    }
}

3、尾插法建立单链表

头插法建立链表虽然算法简单，但生成的链表中结点的次序和输入的顺序相反。就像现实生活中我们都反对插队的行为，我们在编程中也可以不这么干，我们可以把思维逆过来：把新结点都插入到最后，这种插法我们也称为尾插法。这个方法也是考试的重点。

该方法从一个空表开始依次读取数组a中的元素，生成一个新结点s，将读取的数组元素存放到该结点的数据域中，然后将其插入当前链表的表尾上，知道数组a中所有元素读完位置。为此需要增加一个尾指针r，使其始终指向当前链表的尾结点，每插入一个新结点后让r指向这个新结点，最后还需要将r所指结点（尾结点）的next域置空。代码如下：

void CreatListR(LinkNode *&L,ElemType a[],int n)
{
    LinkNode *s,*r;
    L = (LinkNode *)malloc(sizeof(LinkNode));//创建头结点
    r = L;//r始终指向尾结点，初始时指向头结点
    for(int i = 0;i<n;i++)//循环建立数据结点
    {    
        s = (LinkNode *)malloc(sizeof(LinkNode));
        s -> data = a[i];//创建数据结点s
        r->next = s;//将结点s插入结点r之后
        r = s;
    }
    r->next = NULL;//将尾结点的next域置为NULL
}

十、单链表的整表删除

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

-声明结点p和q；

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

-循环执行释放p和将q赋值给p的操作；

代码如下：

Status ClearList（LinkList *L）
{
    LinkList p,q;
    p = (*L)->next;
    
    while(1)
    {
        q = p->next;
        free(p);
        p = q;
    }
    (*L)->next = NULL;

    return 1;
}

在这段算法代码里，常见的错误就是有些朋友会觉得q变量没有存在的必要，只需要在循环体内直接写free（p）；p—>next；即可？这里我们要知道的是：p是一个结点，它除了有数据集，还有指针域。当我们做free（p）的时候，其实是对它整个结点进行删除和内存释放的工作，会把下一个环节指向的指针也给释放掉了。而我们整表删除是需要一个个结点删除的，所以我们就需要q来记载p的下一个结点。