链表（详解）

一、链表

1.1、什么是链表

1、链表是物理存储单元上非连续的、非顺序的存储结构，数据元素的逻辑顺序是通过链表的指针地址实现，有一系列结点（地址）组成，结点可动态的生成。

2、结点包括两个部分：（1）存储数据元素的数据域（内存空间），（2）存储指向下一个结点地址的指针域。

3、相对于线性表顺序结构，操作复杂。

1.2、链表的分类

链表的结构非常多样，以下的情况组合起来就有8种链表结构

（1）单项和双向

（2）带头和不带头

（3）循环和不循环

1.3、链表和顺序表的比较

（1）数组：使用一块连续的内存空间地址去存放数据，但

例如：
int  a[5]={1,2,3,4,5}。突然我想继续加两个数据进去，但是已经定义好的数组不能往后加，只能通过定义新的数组

int b[7]={1,2,3,4,5,6,7};  这样就相当不方便比较浪费内存资源,对数据的增删不好操作。

（2）链表：使用多个不连续的内存空间去存储数据， 可以 节省内存资源（只有需要存储数据时，才去划分新的空间），对数据的增删比较方便

注意：

1.链式结构在逻辑上是连续的，但在物理上不一定连续

2.现实中的结点一般都是从堆上申请出来的

3.从堆上申请的空间，是按照一定的策略来分配的，两次申请的空间可能连续，也可能不连续

二、无头单向非循环链表

2.1、无头单向非循环链表的结构

链表有一个数据域存放数据，一个指针域存放下一个结点的地址。

typedef int SLTDataType;typedef struct SListNode
{SLTDataType data;struct SListNode* next;
}SLTNode;

2.2、无头单向非循环链表的实现

//打印
void SLTPrint(SLTNode* phead);//创建一个新节点
SLTNode* BuySListNode(SLTDataType x);//尾增
void SLTPushBack(SLTNode** pphead, SLTDataType x);//头增
void SLTPushFront(SLTNode** pphead, SLTDataType x);//尾删
void SLTPopBack(SLTNode** pphead);//头删
void SLTPopFront(SLTNode** pphead);// 作业
SLTNode* SLTFind(SLTNode* phead, SLTDataType x);// 在pos之前插入x
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x);// 在pos以后插入x   
void SLTInsertAfter(SLTNode* pos, SLTDataType x);// 删除pos位置
void SLTErase(SLTNode** pphead, SLTNode* pos);// 删除pos的后一个位置
void SLTPopAfter(SLTNode* pos);// 单链表的销毁
void SListDestroy(SLTNode** pphead);

2.2.1、创建一个新节点

SLTNode* BuySListNode(SLTDataType x)
{SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));if (newnode == NULL){perror("malloc");exit(-1);}newnode->data = x;newnode->next = NULL;return newnode;
}

创建一个新节点，用malloc开辟一个链表节点空间，强制转换成链表结构体，将data置为X，将next置为空，并返回新节点。

2.2.2、单链表的尾插

//单链表的尾插
void SLTPushBack(SLTNode** pphead, SLTDataType x)
{assert(pphead);SLTNode* newnode = BuySListNode(x);//没有一个节点if (*pphead == NULL){*pphead = newnode;}else{SLTNode* tail = *pphead;while (tail->next != NULL){tail = tail->next;}tail->next = newnode;}
}

单链表的尾插首先需要判断是否是空链表，如果为空就把该节点置为头节点，若不为空，先便利找到尾结点，然后将新节点插入尾节点后面。

2.2.3、单链表的头插法

//单链表的头插法   效率高，简单
void SLTPushFront(SLTNode** pphead, SLTDataType x)
{assert(pphead);SLTNode* newnode = BuySListNode(x);newnode->next = *pphead;*pphead = newnode;
}

头插法相对简单，只需要将新节点插到头结点的前面，并且将头结点指针赋给新节点。

2.2.4、单链表的尾删

//单链表的尾删
void SLTPopBack(SLTNode** pphead)
{assert(pphead);//空assert(*pphead);// 1个节点if ((*pphead)->next == NULL){free((*pphead));*pphead = NULL;}else  //两个或者多个节点{   //方法一 /*SLTNode* tail = *pphead;while (tail->next->next){tail = tail->next;}free(tail->next);tail->next = NULL;*///方法二SLTNode* tail = *pphead;SLTNode* tailprev = NULL;while (tail->next){tailprev = tail;tail = tail->next;}free(tail);tail = NULL;tailprev->next = NULL;}
}

和尾插法一样，首先先判断链表是否只有一个节点或者没有节点（为空），将会最后一个链表置空，如果超过一个节点，先找到倒数第二个节点，然后置空最后一个节点，将倒数第二个节点的next置空

2.2.5、单链表的头删法

//链表的头删法   效率高，简单
void SLTPopFront(SLTNode** pphead)
{assert(pphead);assert(*pphead);SLTNode* newnode = (*pphead)->next;free(*pphead);*pphead = newnode;
}

free第一个节点，将头指针后移一位。

2.2.6、单链表的查找

//查找元素  修改
SLTNode* SLTFind(SLTNode* phead, SLTDataType x)
{SLTNode* cur = phead;while (cur){if (cur->data == x){return cur;}cur = cur->next;}return NULL;
}

借助cur指针，便利链表，cur=cur->next;若cur->data==x,返回cur,没找到返回NULL。

2.2.7、在pos之前插入

//在pos之前插入
//  传头指针是因为有可能时头插
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{assert(pos);if (pos == *pphead){SLTNode* newnode = BuySListNode(x);newnode->next = *pphead;*pphead = newnode;}else{SLTNode* prev = *pphead;while (prev->next != pos){prev = prev->next;}SLTNode* newnode = BuySListNode(x);prev->next = newnode;newnode->next = pos;}
}

在pos位置插入，相对

2.2.8、在pos之后插入

//在pos之后插入
void SLTInsertAfter(SLTNode* pos, SLTDataType x)
{assert(pos);SLTNode* newnode = BuySListNode(x);newnode->next = pos->next;pos->next=newnode;}

2.2.9、删除pos位置

//删除pos位置
void SLTErase(SLTNode** pphead, SLTNode* pos)
{assert(pos);if (pos == *pphead){SLTPopFront(pphead);}else{SLTNode* prev = *pphead;while (prev->next != pos){prev = prev->next;}prev->next = pos->next;free(pos);//pos == NULL;  //可有可无，因为pos只是形参，对他的操作不影响外部的节点}
}

2.2.10、删除pos后一位置

//删除pos后一位置
void SLTPopAfter(SLTNode* pos)
{assert(pos);assert(pos->next == NULL);SLTNode* posnext = pos->next;pos->next = posnext->next;free(posnext);posnext = NULL;
}
//删除一个pos,没有头节点
// 把pos下一个节点的值赋给pos,将下一个节点删除
//但是无法删除尾结点

2.2.11、单链表的销毁

//单链表的销毁
void SListDestroy(SLTNode** pphead)
{assert(*pphead);SLTNode* pre = *pphead;SLTNode* p = pre->next;while (p!=NULL){free(pre);pre = p;p = p->next;}free(pre->next);pre->next = NULL;
}

三、带头双向循环链表

双向链表的原理与单链表类似，双向链表需要两个指针来链接，一个指向前面的，一个指向后面的。同时需要一个head，头链表，方便操作。

3.1带头双向链表实现

3.1.1、创建结构体

typedef int DataType;
typedef struct ListNode
{struct ListNode *next;struct ListNode *pre;DataType data;
}LTNode;

此结构中比单链表结构增加一个结构体指针pre，用于存放上一个节点的地址。
next是存放一个节点的地址。
data是存放数据。

3.1.2、申请结点

LTNode* BuyListNode(DataType x)//申请结点
{LTNode* node = (LTNode*)malloc(sizeof(LTNode));if (node == NULL){perror( "malloc fail");exit(-1);}node->next = NULL;node->pre = NULL;node->data = x;return node;
}

动态申请结点，函数返回的是一个指针类型，用malloc开辟一个LTNode大小的空间，并用node指向这个空间，再判断是否为空，如为空就perror，显示错误信息。反之则把要存的数据x存到newnode指向的空间里面，把指针置为空。

3.1.3、初始化创建头结点

LTNode* LTInit()//初始化创建头结点
{LTNode* phead = BuyListNode(0);phead->next = phead;phead->pre = phead;return phead;
}

单链表开始是没有节点的，可以定义一个指向空指针的结点指针，但是此链表不同，需要在初始化函数中创建个头结点，它不用存储有效数据。因为链表是循环的，在最开始需要让头结点的next和pre指向头结点自己。
因为其他函数也不需要用二级指针（因为头结点指针是不会变的，变的是next和pre，改变的是结构体，只需要用结构体针即可，也就是一级指针）为了保持一致此函数也不用二级指针，把返回类型设置为结构体指针类型。

3.1.4、打印链表

void LTPrint(LTNode* phead)//打印链表
{assert(phead);LTNode* cur = phead->next;while (cur!=phead){printf("%d ", cur->data);cur = cur->next;}printf("\n");
}

打印链表，先断言phead，它不能为空，再把头结点下个地址存到cur中，用while循环去遍历，终止条件是等于头指针停止，因为他是循环的，并更新cur。

3.1.5、在pos位置之前插入

void LTInsert(LTNode* pos, DataType x)//在pos位置之前插入数据
{assert(pos);LTNode* node = BuyListNode(x);LTNode* bef = pos->pre;bef->next = node;node->pre = bef;node->next = pos;pos->pre = node;
}

断言pos，不能为空，插入数据先申请一结点放到定义的node指针变量中，为了不用考虑插入顺序，先把pos前面的存到bef中，然后就可以随意链接：
bef指向新节点，新节点前驱指针指向bef，新节点指向pos，pos前驱指针指向新节点。

3.1.6、删除任意位置数据

void LTErase(LTNode* pos)//删除pos位置数据
{assert(pos);pos->pre->next = pos->next;pos->next->pre = pos->pre;free(pos);
}

删除把pos位置之前的结点直接指向pos的下一个结点，把pos下一个结点的前驱指针指向pos之前的结点。

3.1.7、尾插

void LTPushBack(LTNode* phead, DataType x)//尾插
{/*assert(phead);//复杂方法/*LTNode* newnode = BuyListNode(x);LTNode* tail = phead->prev;tail->next = newnode;newnode->prev = tail;newnode->next = phead;phead->prev = newnode;*/assert(phead);//简便方法LTInsert(phead, x);
}

简便方法：尾插是在尾部插入，用简便方法调用LTInsert函数，传入头指针和x。

复杂方法是：申请结点newnode，把头指针前的上一个结点存到尾指针变量中，再双向链接newnode，最后还得把头和尾（刚申请的结点）循环起来。

3.1.8、尾删

void LTPopBack(LTNode* phead)//尾删
{//assert(phead);//复杂方法//assert(phead->next != phead);  // 空//LTNode* tail = phead->prev;//LTNode* tailPrev = tail->prev;//tailPrev->next = phead;//phead->prev = tailPrev;//free(tail);assert(phead);//简便方法assert(phead->next != phead);  // 空LTErase(phead->pre);
}

简便方法：因为是尾删，删的是尾部，直接调用LTErase函数传入头指针的上一个结点，也就是尾部，因为是双向循环不用遍历直接直到尾部。

复杂方法：先把头结点上一个结点地址存起来，再把尾部的上一个结点地址存起来，再把第二次存的直接链接头部，头部链接第二次存的结点，再把第一次的结点释放掉。

3.1.9、头插

void LTPushFront(LTNode* phead, DataType x)//头插
{//assert(phead);//复杂方法//LTNode* newnode = BuyListNode(x);//LTNode* back = phead->next;//phead->next = newnode;//newnode->prev = phead;//newnode->next = back;//back->prev = newnode;assert(phead);//简便方法LTInsert(phead->next, x);
}

简便方法：因为是头插直接调用LTInsert函数传 头结点下一个结点指针和x。

复杂方法：申请结点存到newnode，再把头结点下一个结点地址存到指针back里，头部和新节点和back，三节点双向链接。

3.1.10、头删

void LTPopFront(LTNode* phead)//头删
{//assert(phead);//assert(phead->next != phead); // 空/*LTNode* back = phead->next;LTNode* second = back->next;free(back);phead->next = second;second->prev = phead;*/assert(phead);assert(phead->next != phead);  // 空LTErase(phead->next);}

简便方法：因为头删，直接调LTErase函数传入头结点下一个指针。

复杂方法：先把头结点下一个结点地址存到back指针里，再把back一个结点地址存到second指针里，先释放中间的back，最后头结点和second双向链接。

3.1.11、查找元素

LTNode* LTFind(LTNode* phead, DataType x)//查找
{assert(phead);LTNode* cur = phead->next;while (cur!=phead){if (cur->data == x){return cur;}cur = cur->next;}return NULL;}

查找把头结点下一个结点存到cur，然后用while循环遍历，终止条件是cur等于头结点指针，如果cur等于x，直接返回cur指针，再更新cur，最后遍历完返回NULL，表示没有该数据。

3.1.12、释放链表

void LTDestroy(LTNode* phead)//释放链表
{assert(phead);LTNode* cur = phead->next;while (cur != phead){LTNode* next = cur->next;free(cur);cur = next;}free(phead);
}

释放链表从头开始释放，把头结点下一个结点存到cur中，再用用while循环，终止条件是cur不等于头指针，在里面把cur下一个指针存到next中，释放掉cur，再把next更新为cur。
最后头结点也是申请的，也得释放。

3.1.13、判断是否为空

bool LTEmpty(LTNode* phead)//判断是否为空
{assert(phead);return phead->next == phead;
}

3.1.14、求链表长度

size_t LTSize(LTNode* phead)//求链表长度
{assert(phead);size_t size = 0;LTNode* cur = phead->next;while (cur != phead){++size;cur = cur->next;}return size;
}

求链表长度，先把头结点下一个结点存到cur中，再用while循环遍历终止条件是cur等于头结点，用size++记录长度，并更新cur，最后返回size，32位机器下是无符号整型size_t。


到这里链表的基本问题就解释完了，相信多多少少会解决大家心头的疑问，在数据结构的学习中应当善于思考，多画图，死磕代码，注意细节，将伪代码转换为代码，这样才能很好的掌握数据结构的有关知识，共勉，加油！！！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.hqwc.cn/news/89782.html

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

[JavaWeb]【十三】web后端开发-原理篇

[JavaWeb]【十三】web后端开发-原理篇

目录 一、SpringBoot配置优先级 1.1 配置优先级比较 1.2 java系统属性和命令行参数 1.3 打包运行jar 1.4 综合优先级​编辑 二、Bean管理 2.1 获取bean 2.2 bean作用域 2.2.1 五种作用域 2.2.2 配置作用域 2.3 第三方bean 2.3.1 编写公共配置类 三、SpringBoot原理 …
阅读更多...
【mq】如何保证消息可靠性

【mq】如何保证消息可靠性

文章目录 mq由哪几部分组成rocketmqkafka 为什么需要这几部分nameserver/zookeeper可靠性 broker可靠性 生产者消费者 mq由哪几部分组成 rocketmq kafka 这里先不讨论Kafka Raft模式 比较一下，kafka的结构和rocketmq的机构基本上一样，都需要一个注册…
阅读更多...
Autoware.universe部署05：实车调试

Autoware.universe部署05：实车调试

文章目录 一、建图1.1 点云地图1.2 高精地图 二、参数配置三、传感器数据通信接口3.1 雷达点云3.2 图像3.3 IMU3.4 GNSS RTK 四、实车调试4.1 编写启动4.2 修改传感器外参4.3 修改车身参数4.4 实车调试 本文介绍了 Autoware.universe 在实车上的部署，本系列其他文章…
阅读更多...
fatal: ServicePointManager 不支持具有 socks5 方案的代理。

fatal: ServicePointManager 不支持具有 socks5 方案的代理。

报错 解决前 git config --global --list 查看git的设置 解决后 // 代理更改为http (7890是我的代理软件clash的port默认的，有些博客使用的是1080，依个人情况而定) git config --global http.proxy http://127.0.0.1:7890 git config --global https…
阅读更多...
[递归] 自然数分解之方案数

[递归] 自然数分解之方案数

[递归] 自然数分解之方案数_慕梅^的博客-CSDN博客 同样的思路&#xff0c;只是解决的问题不一样 #include <cstdio> #include <algorithm> #include <cstring> using namespace std;int func(int pre,int now){int max_ -1;for (int i1;2*i<now;i){if …
阅读更多...
【模拟】算法实战

【模拟】算法实战

文章目录 一、算法原理二、算法实战1. leetcode1576 替换所有的问号2. leetcode495 提莫攻击3. leetcode6 N字形变换4. leetcode38 外观数列5. leetcode1419 数青蛙 三、总结 一、算法原理 模拟就是用计算机来模拟题目中要求的操作&#xff0c;模拟题目通常具有代码量大、操作…
阅读更多...
【校招VIP】前端算法考察之排序

【校招VIP】前端算法考察之排序

考点介绍&#xff1a; 不同的场景中&#xff0c;不同的排序算法执行效率不同。 稳定&#xff1a;冒泡、插入、归并 不稳定&#xff1a;选择、快速、堆排序、希尔排序 『前端算法考察之排序』相关题目及解析内容可点击文章末尾链接查看&#xff01; 一、考点题目 1、使用js实…
阅读更多...
Linux CentOS安装抓包解包工具Wireshark图形化界面

Linux CentOS安装抓包解包工具Wireshark图形化界面

1.Wireshark介绍 Wireshark 是一个开源的网络协议分析工具&#xff0c;它能够捕获和分析网络数据包&#xff0c;提供深入的网络故障排除、网络性能优化和安全审计等功能。它支持跨多个操作系统&#xff0c;包括 Windows、macOS 和 Linux。 2.Wireshark主要使用方法 捕获数据…
阅读更多...
vue3-vuex持久化实现

vue3-vuex持久化实现

vue3-vuex持久化实现 一、背景描述二、实现思路1.定义数据结构2.存值3.取值4.清空 三、具体代码1.定义插件2.使用插件 四、最终效果 一、背景描述 有时候我们可能需要在vuex中存储一些静态数据&#xff0c;比如一些下拉选项的字典数据。这种数据基本很少会变化&#xff0c;所以…
阅读更多...
Linux特殊指令

Linux特殊指令

目录 1.dd命令 2.mkfs格式化 3.df命令 4.mount实现硬盘的挂载 5.unshare 1.dd命令 dd命令可以用来读取转换并输出数据。 示例一&#xff1a; if表示infile&#xff0c;of表示outfile。这里的/dev/zero是一个特殊文件&#xff0c;会不断产生空白数据。 bs表示复制一块的大…
阅读更多...
SpringBoot+MyBatisPlus+MySql+vue2+elementUi的案例、java访问数据库服务、java提供接口服务

SpringBoot+MyBatisPlus+MySql+vue2+elementUi的案例、java访问数据库服务、java提供接口服务

文章目录 前言后端关键代码前端关键代码完整代码 前言 1、项目不使用前后端分离。 2、在创建SpringBoot的时候要注意各个插件间的版本问题。 3、后端技术SpringBootMyBatisPlusMySql。 4、前端技术vue2elementUi。 后端关键代码 简单介绍 1、数据库名称ssm_db 2、表名称tbl_bo…
阅读更多...
银河麒麟服务器、centos7服务器mysql离线安装：通过获取临时密码进行登录修改新密码

银河麒麟服务器、centos7服务器mysql离线安装：通过获取临时密码进行登录修改新密码

离线安装脚本 cd /home/zenglg/mysql5.7# 判断mysql是否安装# 下面这种方法必须是rpm安装的判断才有效&#xff0c;不通用# IS_INSTALLED$(rpm -qa |grep mysql)# if [ $? -eq 0 ]# 下面的判断方法是查询版本号&#xff0c;比较通用SQL_VERSIONmysql -V | grep -i -o -P 5.7.4…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023