数据结构——链表

最新推荐文章于 2024-10-02 10:19:33 发布
最新推荐文章于 2024-10-02 10:19:33 发布
阅读量1k 收藏 22
点赞数 22
分类专栏： 数据结构 文章标签： 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qixi_ao/article/details/141612920
版权

单链表

基本概念

  • 顺序表：顺序存储的线性表。
  • 链式表：链式存储的线性表，简称链表。

既然顺序存储中的数据因为挤在一起而导致需要成片移动，那很容易想到的解决方案是将数据离散地存储在不同内存块中，然后在用来指针将它们串起来。这种朴素的思路所形成的链式线性表，就是所

谓的链表。

顺序表和链表在内存在的基本样态如下图所示：

请添加图片描述

链表的分类

根据链表中各个节点之间使用指针的个数，以及首尾节点是否相连，可以将链表细分为如下种类：

  1. 单向链表
  2. 单向循环链表
  3. 双向循环链表

这些不同链表的操作都是差不多的，只是指针数目的异同。以最简单的单向链表为例，其基本示意图

如下所示：

请添加图片描述

上图中，所有的节点均保存一个指针，指向其逻辑上相邻的下一个节点（末尾节点指向空）。另外注

意到，整条链表用一个所谓的头指针 head 来指向，由 head 开始可以找到链表中的任意一个节点。

head 通常被称为头指针。

链表的基本操作，一般包括：

  1. 节点设计
  2. 初始化空链表
  3. 增删节点
  4. 链表遍历
  5. 销毁链表

下面着重针对这几项常见操作，讲解单向链表的处理。

单链表节点设计

单向链表的节点非常简单，节点中除了要保存用户数据之外（这里以整型数据为例），只需要增加一

个指向本类节点的指针即可，如下所示：

typedef int DATA;
typedef struct Node
{
    DATA data; // 存储数据---数据域
    struct Node *next; // 存储下一个节点的地址---指针域
} NODE;

单链表初始化

首先，空链表有两种常见的形式。一种是带所谓的头结点的，一种是不带头结点的。所谓的头结点是

不存放有效数据的节点，仅仅用来方便操作，如下：

请添加图片描述

而不带头结点的空链表如下所示：

请添加图片描述

注意：

  • 头指针 head 是必须的，是链表的入口
  • 头节点是可选的，为了方便某些操作

由于头结点是不存放有效数据的，因此如果空链表中带有头结点，那么头指针 head 将永远不变，这会给以后的链表操作带来些许便捷。

下面以带头结点的链表为例，展示单向链表的初始化的示例代码：

int slist_create(NODE** head,DATA data)
{
    NODE* p = (NODE*)malloc(sizeof(NODE));
    if(!p)
    {
        return -1;
    }
    p -> data = data;
    p -> next = NULL;
    *head = p;
    return 0;
}

单链表增删节点

相对于顺序表需要整片移动数据，链表增删节点只需要修改几个相关指针的指向，动作非常快速。与顺序表类似，可以对一条链表中的任意节点进行增删操作，示例代码是：

int slist_addHead(NODE **head, DATA data)
{
    NODE *p = (NODE *)malloc(sizeof(NODE));
    if (!p)
    {
        return -1;
    }
    p->data = data;
    p->next = *head;
    *head = p;
    return 0;
}
int slist_addTail(NODE **head, DATA data)
{
    NODE *pNew = (NODE *)malloc(sizeof(NODE));
    if (!pNew)
    {
        return -1;
    }
    pNew->data = data;
    pNew->next = NULL;
    NODE *p = *head, *q = NULL;
    if (!p)
    {
        *head = pNew;
        return 0;
    }
    while (p)
    {
        q = p;
        p = p->next;
    }
    q->next = pNew;
    return 0;
}
int slist_insert(NODE **head, DATA pos, DATA data)
{
    NODE *pNew = (NODE *)malloc(sizeof(NODE));
    if (!pNew)
        return -1;
    pNew->data = data;
    pNew->next = NULL;
    NODE *p = *head, *q = NULL;
    if (!p)
    {
        *head = pNew;
        return 0;
    }
    if (memcmp(&(p->data), &pos, sizeof(DATA)) == 0)
    {
        pNew->next = *head;
        *head = pNew;
        return 0;
    }
    while (p)
    {
        if (memcmp(&(p->data), &pos, sizeof(DATA)) == 0)
        {
            pNew->next = p;
            q->next = pNew;
            return 0;
        }
        q = p;
        p = p->next;
    }
    q->next = pNew;
    return 0;
}
int slist_update(const NODE *head, DATA old, DATA newdata)
{
    NODE *p = NULL;
    if (!(p = slist_find(head, old)))
        return -1;
    p->data = newdata;
    return 0;
}
int slist_delete(NODE **head, DATA data)
{
    NODE *p = *head, *q = NULL;
    if (!p)
        return -1;
    if (memcmp(&(p->data), &data, sizeof(DATA)) == 0)
    {
        *head = p->next;
        free(p);
        return 0;
    }
    while (p)
    {
        if (memcmp(&(p->data), &data, sizeof(DATA)) == 0)
        {
            q->next = p->next;
            free(p);
            return 0;
        }
        q = p;
        p = p->next;
    }
    return -1;
}

注意:

删除链表的节点并不意味着释放其内存，而是将其剔除出链表

单链表的遍历

遍历的意思就是逐个访问每一个节点，对于线性表而言，由于路径唯一的选择就是从头走到尾。因此相当而言比较简单。

下面是单向链表的遍历示例代码，假设遍历每个节点并将其整数数据输出：

NODE* slist_find(const NODE* head,DATA data)
{
    const NODE* p = head;
    while(p)
    {
        if(memcmp(&(p -> data),&data,sizeof(DATA)) == 0)
    {
        return (NODE*)p;
    }
    p = p -> next;
    }
    return NULL;
}
void slist_showAll(const NODE* head)
{
    const NODE* p = head;
    while(p)
    {
        printf("%d ",p -> data);
        p = p -> next;
    }
    printf("\n");
}

单链表的销毁

由于链表中的各个节点被离散地分布在各个随机的内存空间，因此销毁链表必须遍历每一个节点，释放每一个节点。

注意：

销毁链表时，遍历节点要注意不能弄丢相邻节点的指针

void slist_destroy(NODE** head)
{
    NODE* p = *head, *q = NULL;
    while(p)
    {
        q = p;
        p = p -> next;
        free(q);
    }
    *head = NULL;
}

完整代码

  • singList.h
#ifndef __SEQLIST_H
#define __SEQLIST_H

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>

// 定义顺序表的结构体
typedef struct
{
    int capacity;// 顺序表的容量（顺序表本质上是数组）
    int last;    // 末元素的下标
    int *data;   // 数据，其实是一个存放多个int的容器
} seqList;

// 创建顺序表（顺序表的初始化）
seqList *initList(int cap);

// 向顺序表的表头插入一个新数据
bool insert(seqList *list,int data);

// 判断顺序表是否满了
bool isFull(seqList *list);

// 遍历顺序表中的元素
void show(seqList *list);

// 将顺序表中指定的某个元素删除
bool removeNode(seqList *list,int data);

// 销毁顺序表
void destroy(seqList *s);
#endif

slist.c

#include "slist.h"

/*
@function:   int slist_create(NODE** head,DATA data);
@berif:      创建单项链表
@argument:   head: 指向头指针变量的地址，用来接收首节点地址
             data: 存储在节点中的数据
@return :    成功返回 0
             失败返回 -1
*/
int slist_create(NODE **head, DATA data)
{
    // 申请内存
    NODE *p = (NODE *)malloc(sizeof(NODE));
    // 校验
    if (!p)
    {
        return -1;
    }
    // 赋值操作
    p->data = data;
    p->next = NULL;

    *head = p;

    return 0;
}

/*
@function:   int slist_addHead(NODE** head,DATA data);
@berif:      向链表头部插入一个节点数据（头插法）
@argument:   head: 指向头指针变量的地址，用来接收首节点地址
             data: 存储在新节点中的数据
@return :    成功返回 0
             失败返回 -1
*/
int slist_addHead(NODE **head, DATA data)
{
    // 创建一个新节点（申请内存）
    NODE *p = (NODE *)malloc(sizeof(NODE));
    // 校验
    if (!p)
    {
        return -1;
    }
    // 给节点添加新数据（创建节点的目的是存储数据）
    p->data = data;
    // 新节点指向原本的head节点
    p->next = *head;

    // 我们要让p作为我们新的head
    *head = p;

    return 0;
}

/*
@function:   int slist_addTail(NODE** head,DATA data);
@berif:      向链表尾部插入一个节点数据（尾插法）
@argument:   head: 指向头指针变量的地址，用来接收首节点地址
             data: 存储在新节点中的数据
@return :    成功返回 0
             失败返回 -1
*/
int slist_addTail(NODE **head, DATA data)
{
    // 创建一个新节点（申请内存）
    NODE *pNew = (NODE *)malloc(sizeof(NODE));
    // 校验
    if (!pNew)
    {
        return -1;
    }

    // 赋值操作
    pNew->data = data; // 存数据
    pNew->next = NULL; // 因为是最后一个节点，所有没有指向

    // 获取尾部节点，默认head头结点就是尾结点，p用来保存真实的尾结点
    NODE *p = *head, *q = NULL;
    if (!p)
    {
        // 如果说头节点不存在，我们直接将新节点作为头结点，一般不会发生
        *head = pNew;
        return 0;
    }

    // 通过一个循环，找尾结点
    while (p)
    {
        // 为什么要定义q，因为p是在变化的
        q = p;
        p = p->next;// 指针向下指
    }

    // 让原本的尾结点指向新插入的的节点，此时新插入的节点变成了尾结点
    q->next = pNew;
    

    return 0;
}


/*
@function:   int slist_insert(NODE** head,DATA pos ,DATA data);
@berif:      向链表节点值为pos的位置插入一个节点数据data
@argument:   head: 指向头指针变量的地址
             pos:  插入节点位置的节点数据
             data: 存储在新节点中的数据
@return :    成功返回 0
             失败返回 -1
*/
int slist_insert(NODE** head,DATA pos,DATA data)
{
    // 创建一个新节点，并申请内存
    NODE *pNew = (NODE*)malloc(sizeof(NODE));
    if(!pNew)
    {
        perror("内存申请失败！");
        return -1;
    }
    // 给新节点赋初值
    pNew->data = data;
    pNew->next = NULL;

    // 声明变量，p是pos对应位置的节点，默认是头结点，q是pos对应节点的上一个节点
    NODE *p = *head,*q = NULL;

    // 第一种情况：头结点不存在
    if(!p)
    {
        // 新节点pNew作为头结点
        *head = pNew;
        return 0;
    }
    // 第二种情况：只有头结点
    if(memcmp(&(p->data),&pos,sizeof(DATA)) == 0)
    {
        // 头插法
        // 新节点的next指向head节点
        pNew->next = *head;
        // 改变指向，将pNew作为新的头结点
        *head = pNew;
        return 0;
    }
    // 第三种情况：既有头结点，也有普通节点
    while (p)
    {
        // 找pos对应位置的节点
        if(memcmp(&(p->data),&pos,sizeof(DATA)) == 0)
        {
            // pNew在p前
            pNew->next = p;
            // pNew在q后
            q->next = pNew;
            return 0;
        }
        q = p;// q在p的前一位，一前（q）一后（p）
        p = p ->next;
    }
    // 尾插法
    q->next = pNew;
    
    return 0;
}

/*
@function:   NODE* slist_find(const NODE* head,DATA data);
@berif:      查找链表数据data
@argument:   head: 指向头指针变量
             data: 待查找的数据
@return :    成功返回节点的地址
             失败返回NULL
*/
NODE* slist_find(const NODE *head,DATA data)
{
    // 创建一个变量，用来接收链表
    const NODE* p = head;

    while(p)
    {
        if(memcmp(&(p->data),&data,sizeof(DATA))==0)
        {
            return (NODE*)p;
        }
        // 移动节点
        p = p->next;
    }
    return NULL;
}

/*
@function:   int slist_update(const NODE* head,DATA old_data,DATA new_data);
@berif:      更新链表数据old_data 为 new_data
@argument:   head: 指向头指针变量
             old_data:  待更新的节点数据
             new_data: 更新后的节点数据
@return :    成功返回  0
             失败返回  -1
*/
int slist_update(const NODE* head,DATA old_data,DATA new_data)
{
    NODE* p = NULL;
    if(!(p = slist_find(head,old_data)))
    {
        return -1;
    }
    p->data = new_data;

    return 0;

}

/*
@function:   void slist_showAll(const NODE* head);
@berif:      遍历链表数据
@argument:   head: 指向头指针变量
@return :    无
*/
void slist_showAll(const NODE* head)
{
    // 创建一个变量用来接收链表
    const NODE* p = head;

    // 遍历链表
    while (p)
    {
        printf("%d ",p->data);
        p = p->next;
    }
    printf("\n");
}

/*
@function:   int slist_delete(NODE** head,DATA data);
@berif:      删除链表中节点值为data的节点
@argument:   head: 指向头指针变量的地址
             data: 删除节点中的数据
@return :    成功返回 0
             失败返回 -1
*/
int slist_delete(NODE** head,DATA data)
{
    // 指针尾随
    NODE *p = *head,*q = NULL;
    
    // 第一种情况：头结点不存在（链表本身不存在），无法操作
    if(!p)
    {
       return -1; 
    }
    // 第二种情况：只有一个节点
    if(memcmp(&(p->data),&data,sizeof(DATA)) == 0)
    {
        *head = p -> next;
        free(p);
        return 0;
    }
    // 第三种情况：有多个节点
    while (p)
    {
        if(memcmp(&(p->data),&data,sizeof(DATA)) == 0)
        {
            q->next = p->next;// p的上一个节点的next指向p的下一个节点
            // 这个回收不会影响到链表的删除
            free(p);
            return 0;
        }

        q = p;
        p = p->next;// p->next代表的是p的下一个节点，将p的下一个节点赋值给p，相当于p移动了一位
    }

    return -1;
}

/*
@function:   void slist_destroy(NODE** head);
@berif:      回收链表
@argument:   head: 指向头指针变量的地址
@return :    无
*/
void slist_destroy(NODE** head)
{
    // 指针尾随
    NODE *p = *head,*q = NULL;

    while(p)
    {
        q = p;// 12
        p = p->next;// 13
        // 回收前一个节点
        free(q);
    }
    *head = NULL;

}

链表优缺点

链式存储中，所有节点的存储位置是随机的，他们之间的逻辑关系用指针来确定，跟物理存储位置无

关，因此从上述示例代码可以很清楚看到，增删数据都非常迅速，不需要移动任何数据。另外，又由

于位置与逻辑关系无关，因此也无法直接访问某一个指定的节点，只能从头到尾按遍历的方式一个个

找到想要的节点。简单讲，链式存储的优缺点跟顺序存储几乎是相对的。

总结其特点如下：

  • 优点

    1. 插入、删除时只需要调整几个指针，无需移动任何数据

    2. 当数据节点数量较多时，无需一整片较大的连续内存空间，可以灵活利用离散的内存

    3. 当数据节点数量变化剧烈时，内存的释放和分配灵活，速度快

  • 缺点

    1. 在节点中，需要多余的指针来记录节点之间的关联。

    2. 所有数据都是随机存储的，不支持立即访问任意一个随机数据。

循环单向链表

所谓的循环，指得是将链表末尾节点循环地指向链表表头。比如，单向链表变成循环链表的示意图如下所示：

请添加图片描述

循环链表的操作跟普通链表操作基本上是一致的，只要针对循环特性稍作修改即可

qixi_ao
关注
专栏目录
数据结构 —— 链表
Labrador_Katie的博客
08-28 1126
链表线性表链表的分类单向链表双向链表循环链表 线性表 线性表：由零个或多个数据元素组成的有限序列。 线性表有两种存储方式： 顺序存储结构——即数组 链式存储结构——即链表 线性表强调： 它是一个序列，元素之间有个先来个后到； 若元素存在多个，则第一个元素无前驱，最后一个元素无后继，其他元素有且只有一个前驱和后继； 线性表强调是有限的。 链表的分类 单向链表 单向链表是最简单的链表形式。我们将链表中最基本的数据称为节点(node)，每一个节点包含了数据块和指向下一个节点的指针。 特点：用一组任意的存储
数据结构——链表 C语言
03-16
设单链表A和B均非递减有序，试设计算法，将A和B合并成非递增有序的单链表C，并要求利用原表A和B的结点空间构造表C。
算法与数据结构——链表
qq_47917118的博客
03-18 344
链表 存储结构 顺序存储:地址连续，用数组 链式存储:地址不连续，用指针(引用，面向对象) 链表 链表中的每一个元素称为“结点”，单链表中每个结点都应包括两个部分：一个是需要用到的实际数据data；另一个就是存储下一个结点地址的指针，即数据域和指针域；而双向链表中，每个结点包括存储其上一个结点地址的指针，用到的数据data和存储下一个结点的指针。数据结构中的每一个数据结点对应于一个存储单元，这种储存单元称为储存结点，也可简称结点。 ———————————————— data为实际存放的数据，next为存
数据结构——链表OJ题
Renswc的博客
02-20 3566
链表oj题练习，链表尾插，我们可以用一个tail指针来记录尾插后的节点，尾插直接在tail节点后即可，这样就不用每次尾插都循环遍历，大大减少了时间复杂度 ，提高了运行效率。
C语言数据结构——链表
热门推荐
zcxmjw的博客
12-22 1万+
大家好，本篇文章主要带领大家了解一下什么是链表，链表的两个主要结构，以及链表和顺序表的差别。
数据结构——链表（Linked List）
jishuxhengjiu的博客
08-31 1万+
使用单向环形链表解决Josephu问题，用不带头结点的单向循环链表先构成一个有n个节点的链表，然后由k节点起从1开始计数，直到第m时，对应节点删除，然后从被删除的下一个节点开始从1开始计数，直到最后一个节点被删除结束算法。2.temp.next = temp.next.next，也就是说需要删除节点的前一个节点本来指向的是删除节点，然后我们使其指向删除节点的下一个节点，直接跳过删除节点，这样该节点也就相当于被删除了。例如N=6，M=5，被杀掉的顺序是：5，4，6，2，3。1.单链表是以节点的方式来存储的。.
golang数据结构——链表
lp15929801907的博客
03-10 1544
golang链表详解
数据结构——链表(java)
薯条和番茄酱的博客
01-03 4393
链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的。
数据结构——链表（C语言版）
2302_80657849的博客
05-05 930
我们只介绍了很简单的链表知识，也只截取了一些有意思的题目。以上便是今天的全部内容。如果有帮助到你，请给我一个免费的赞。因为这对我很重要。编程世界的小比特，希望与大家一起无限进步。
数据结构——链表数组
松仔Log的博客
12-23 6941
链表数组链表数组是什么?链表数组实现 链表数组是什么? 链表数组是由链表构成的数组，即数组每一个元素都是链表 链表数组实现 getBucket()根据hashcode获取桶数 Node数组元素节点 put()获取桶数，判断桶里是否有元素 若无则存到桶内 若有则循环判断当前key是否存在，若存在则覆盖value，不存在则进行链接到末尾 remove()获取桶数，桶里是否有元素，若无则直接返回null，若有则再判断第一个元素是否是要删除的元素 若是则断开头节点，让下一个元素成为头节点 若不是则循环遍历
算法和数据结构——链表.pdf
08-07
在标题《算法和数据结构——链表.pdf》中提到的“算法”指的是对数据的处理过程和步骤，而“数据结构”是指数据在计算机中的组织方式，二者在计算机科学中是基础且核心的概念。在数据结构的学习中，链表是实现算法的...
数据结构——链表的实现
12-29
在这个数据结构——链表的实现中，我们将深入探讨如何用C++来创建一个链表类，并实现搜索、删除、插入和查找等基本操作。 首先，链表的基本思想是使用节点（或称为元素）来存储数据，每个节点包含两部分：数据域和...
数据结构——链表的创建、插入、删除.pdf
08-07
链表是一种基础的数据结构，特别适用于那些插入、删除操作频繁的场景，它的核心优势在于动态性，即能在运行时动态地调整存储空间的大小。 链表由一系列节点构成，每个节点分为两个部分：数据域和指针域。数据域用于...
课设实验-数据结构-线性表-手机销售
ADCvbV的博客
10-02 271
【代码】数据结构-线性表-课设实验-手机销售。
数据结构之AVL树（万字详解）
都市隸人的博客
09-29 1079
本文介绍了数据结构中的AVL树，给出了C++的代码实现
【笔记】数据结构12
m0_52024881的博客
09-29 488
看到的社区的一个知识总结，这里记录一下。
数据结构-3.10.队列的应用
ADCvbV的博客
10-01 294
与5结点相邻的结点只有7，8结点没被处理过(6结点已经入队列了)，因此只需7，8结点入队列，之后5结点出队列；同理处理2结点，与2相邻的1结点已经被处理过，因此无需入队，与2相邻的4结点没被处理过，4结点入队列，最后。之后的结点处理方式与上述同理，直到队列为空就完成了对图的广度优先遍历。遍历到4时，发现它没有子节点，所以4直接出队列即可，无需入子节点。
深入理解 C# 中的集合与数据结构
最新发布
qq_45728381的博客
10-02 977
在日常开发中，集合与数据结构是处理数据的基础工具。C# 提供了一系列强大而灵活的集合类型，帮助我们存储、访问和管理数据。这篇文章将带你了解 C# 中常用的数组、列表、字典、队列、栈、集合和链表的特性和用法。
数据结构与算法分析——链表表示与信息处理
数据结构不仅包括数据的逻辑结构（如链表、数组），还包括物理结构（如内存布局）以及与这些结构相关的操作（如插入、删除、查找）。 1.1节中提到了数据结构的重要性，指出良好的数据结构能够提高算法的效率。例如...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值