【数据结构】C/C++ 带头双向循环链表保姆级教程（图例详解！！）

目录

一、前言

 二、链表的分类

 🥝单链表

 🥝双链表

 🥝循环链表

 🥝带头双向循环链表

 🍍头节点（哨兵位）的作用

 ✨定义：

 ✨作用：

 🍇总结

三、带头双向循环链表 和 单链表 的区别

 四、带头双向循环链表的实现

🍑概念详解

🍋带头双向循环链表的各个接口实现

✨初始化链表 

✨打印链表

✨插入节点

⚡ 头插 

⚡ 尾插 

⚡ 指定位置插入

⚡ 插入升级

 ✨删除结点

⚡头删

⚡尾删 

⚡指定位置删除

⚡删除升级

✨查找元素

 ✨链表判空

 ✨获取链表中的元素个数

 ✨销毁链表

 五、带头双向循环链表的完整代码

✨ List.h 

✨ List.c

✨ test.c

 六、顺序表与链表的区别

七、共勉

一、前言

在前两篇文章中，我们学习了 顺序表（数组） 和 单向不带头非循环 链表。
链接如下：
1️⃣：C/C++ 顺序表
2️⃣：C/C++ 单链表
那么今天，将要学习链表的第三种 双向带头循环链表。

 二、链表的分类

        在前面的文章也介绍过链表的基本情况，但是还是会有朋友分不清链表到底有哪几种，所以今天再来笼统的介绍一下。 
        其实 链表 一共分为 8 种类型，分别如下：

🥝单链表

        通过指针串联在一起的线性结构，每一个节点由两部分组成，一个是 数据域，一个是 指针域（存放指向下一个节点的指针），最后一个节点的指针域指向 NULL（空指针的意思）。
       链接的入口节点称为链表的头结点也就是 head。

 如图所示：

 🥝双链表

单链表中的指针域只能指向节点的下一个节点。

双链表：每一个节点有两个指针域，一个指向下一个节点，一个指向上一个节点。

⭐：双链表 既可以向前查询也可以向后查询。

如图所示： 

 🥝循环链表

循环链表，顾名思义，就是链表 首尾相连。 一般用于解决 ---  约瑟夫环问题

 🥝带头双向循环链表

既然单链表也可以有循环链表，那么双向链表也不例外。

双向链表的 循环带头结点 的链表如下图所示👇

  • 由于这是带头双向循环链表，那么对于链表中的某一个节点 p，它的后继的前驱是谁？当然还是它自己。
  • 比如，在上图的带头双向循环链表中，节点 B 的前驱的后继，还是节点 B。
  • 即：p->next->prev == p == p->prev->next。（prev 表示 前驱指针，next 表示 后继指针）。
  • 这就好比：坐动车时，北京的下一站是天津，那么北京的下一站的前一站是哪里？哈哈哈，当然还是北京。

 这是就会有老铁产生疑问，那么这里的带头（哨兵位）是什么意思呢？它有什么所用呢？

 🍍头节点（哨兵位）的作用

 ✨定义：

头结点 也被称为 哨兵结点，可以用来简化边界条件。


它是一个附加的链表结点，该 结点 作为第一个节点，它的数据域不存储任何东西，只是为了操作的方便而引入的。


也就是说，如果一个链表有哨兵节点的话，那么链表表的第一个元素应该是链表的第二个节点。 

 ✨作用：

说了这么多，那它到底有什么用呢？ 

在很多时候，我们处理某个节点需要用到它的前驱节点。
 
比如删除链表的某个节点，对于没有哨兵的单链表，当待删除的节点为链表的第一个节点，由于没有前驱，需要进行特殊处理，从而代码的复杂性增加。
 
而如果有哨兵节点，则第一个节点的处理方式与其他节点相同，可以统一进行处理。

 🍇总结

        通过上面的 多种链表的结构 估计已经勾起了大家对链表的痛苦的回忆，肯定有老铁会问：这么多种结构，难道每一种链表结构都会经常用吗，我都需要掌握吗❓
       ⭐：我想告诉大家的是，在这8种结构中，虽然很多，但是大家只需要掌握 单链表 和 带头双向循环链表 这种两种结构 就可以应对链表的所有问题啦。

        那又会有老铁问，这两种结构有什么本质上的区别吗❓下面给大家继续解答。

三、带头双向循环链表 和 单链表 的区别

  区别1： 指针个数

带头双向循环链表：每个节点有两个指针，分别指向前一个节点和后一个节点；
单向链表：每个节点只有一个指针，指向下一个节点。

 区别2： 遍历方式

带头双向循环链表：可以从任意节点开始向前或向后遍历整个链表
单向链表：只能从头节点开始顺序遍历

 区别3：插入和删除操作

带头双向循环链表：插入和删除操作相对方便，因为可以直接调整前驱和后继节点的指针；

单向链表：在进行插入和删除时，需要更多的操作来调整节点之间的链接关系

 区别4：空间占用

带头双向循环链表：相较于单向链表需要额外的空间来存储每个节点的前驱指针。这在一些特定场景下可能会带来一定的开销。

  区别6：双向性

 带头双向循环链表：可以在节点内部通过前驱指针和后继指针来实现双向的遍历和操作。这使得在某些场景下，双向链表更加方便和高效，例如需要反向遍历链表或者需要在给定节点处进行插入和删除操作

   区别7：内存占用

带头双向循环链表：相对于单向链表，每个节点额外存储一个前驱指针和一个后继指针，使得双向链表在存储上需要更多的内存空间。这是一个需要考虑的因素，尤其是在链表节点数量较大或内存有限的情况下。 

 ⭐总结

  • 无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。另外这种结构在笔试面试中出现很多。
  • 带头双向循环链表：结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势，实现反而简单了，后面我们代码实现了就知道了。

 四、带头双向循环链表的实现

🍑概念详解

带头双向循环链表：带头双向循环链表也是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱

节点： 

  1. 我们把存储数据元素信息的域称为数据域。
  2. 存储数据元素之间的链接信息即下一个存储数据元素地址的部分称为指针域。
  3. 由数据域和指针域组成的数据元素A的存储映像称为节点。

 🍋带头双向循环链表的各个接口实现

✨初始化链表 

带头双向循环链表是单链表中扩展出来的结构，所以它的很多操作是和 单链表 相同的，甚至理解起来比单链表更简单。

首先，还是先定义一个结点类型，与单向链表相比，带头双向循环链表的结点类型中需要多出一个 前驱指针，用于指向前面一个结点，实现双向。

📝 代码示例 

typedef int Datetype;  // 存储的数据类型// 定义  -- 带头双向循环链表 的节点 ----
typedef struct ListNode
{Datetype data;           // 数据域struct ListNode* next;   // 后驱指针struct ListNode* prev;   // 前驱指针
}LN;
  •  在初始化之前，先申请一个 带哨兵位 的头结点，头结点的前驱和后继指针都指向自己，使得链表一开始便满足循环。然后再用一个 初始化函数 对链表进行初始化。

 📝 代码示例

// 新增一个节点
LN* BuyListNode(Datetype x)
{// 创建一个新的节点LN* newnode = (LN*)malloc(sizeof(LN));// 判断这个节点是否创建成功if (newnode == NULL){printf("malloc fail\n");exit(-1);  // 终止程序}// 节点创建成功，开始给节点赋值newnode->data = x;newnode->next = NULL;newnode->prev = NULL;return newnode;
}// 带头双向循环链表的---初始化
LN* ListInit()
{// 创建一个头节点  这个头节点充当 --- 哨兵位---不存储有效数据LN* phead = BuyListNode(0);// 起始时只有头节点，让它的前驱和后继都指向自己// 使得链表一开始就满足循环phead->next = phead;phead->prev = phead;return phead;
}

注意：第一个是 头结点，也被称为 带哨兵位 的结点，它的数据域一般是不存放数据的

 ✨打印链表

 打印 带头双向循环链表 ，是从头结点的后一个结点处开始，向后遍历并打印，直到遍历到头结点处时便停止。

// 打印链表
// 注意：打印是从 哨兵位 的下一个节点开始打印
void ListPrint(LN* phead)
{//  防止为空链表assert(phead);printf("当前链表为：\n");printf("\n");printf("哨兵位<==>");// 从头结点的后一个结点开始打印LN* cur = phead->next;// 因为是循环链表 所以当 cur指针指向头节点的时候，说明已经打印结束while (cur != phead){printf("%d<==>", cur->data);cur = cur->next;}printf("NULL");printf("\n");printf("\n");
}

 注意：第一个是 头结点，也被称为 带哨兵位 的结点，它是用来 站岗 的，所以不需要打印。

✨插入节点

带头双向循环链表的插入操作分为 3 种情况： 

（1）头插
（2）尾插
（3）在指定 pos 位置之前插入 

⚡ 头插 

进行头插时，需要申请一个新的结点，将 新结点 插入到 头结点 与 头结点的后一个结点 之间即可。

📝 代码示例 

// 头插
void ListPush_front(LN* phead, Datetype x)
{//  防止为空链表assert(phead);LN* front = phead->next;  // 头节点就是哨兵位的后驱指针LN* newnode = BuyListNode(x); // 申请一个结点，数据域赋值为x/*建立新结点与头结点之间的双向关系*/phead->next = newnode;newnode->prev = phead;//建立新结点与beHind结点之间的双向关系newnode->next = front;front->prev = newnode;// 头插--升级版// ListInsert(phead->next, x);
}

注意：第一个是 哨兵结点，所以不能在它的前面插入。 

 ⚡ 尾插 

尾插也是一样，申请一个新结点，将新结点插入到头结点和头结点的前一个结点之间即可。

因为链表是循环的，头结点的前驱指针直接指向最后一个结点，所以我们不必遍历链表找尾。

 📝 代码示例

// 尾插
void ListPush_back(LN* phead, Datetype x)
{//  防止为空链表assert(phead);LN* tail = phead->prev;  // 尾节点就是哨兵位的前驱指针LN* newnode = BuyListNode(x); // 申请一个结点，数据域赋值为x/*建立新结点与头结点之间的双向关系*/newnode->next = phead;phead->prev = newnode;/*建立新结点与tail结点之间的双向关系*/tail->next = newnode;newnode->prev = tail;// 尾插--升级版// ListInsert(phead, x);
}
⚡ 指定位置插入

 这里的指定插入，是在指定的 pos 位置的 前面 插入结点。

这里 pos 是指定位置的 地址，那么如何得到这个地址呢？很简单，需要用到上面的 查找函数。

然后，我们只需申请一个新结点插入到 指定位置结点 和其 前一个结点 之间即可。

 动图演示👇

📝 代码示例 

// 在pos位置的前面插入
void ListInsert(LN* pos, Datetype x)
{//  防止当前没有pos位置assert(pos);LN* posPrev = pos->prev; // 记录 pos 指向结点的前一个结点LN* newnode = BuyListNode(x); // 申请一个结点，数据域赋值为x/*建立新结点与posPrev结点之间的双向关系*/posPrev->next = newnode;newnode->prev = posPrev;/*建立新结点与pos指向结点之间的双向关系*/newnode->next = pos;pos->prev = newnode;
}
 ⚡ 插入升级

 我们仔细回顾一下，刚刚写的 头插 和 尾插，有没有发现什么规律呢？

没错，头插 其实就是在 哨兵结点 的 下一个结点 插入数据，所以我们可以用上面写的 ListInsert 函数来实现。

📝 代码升级 

// 头插
void ListPush_front(LN* phead, Datetype x)
{//  防止为空链表assert(phead);// 头插--升级版ListInsert(phead->next, x);
}

那么 尾插 呢？其实就是在 哨兵结点 的 前面 插入结点。 

 📝 代码升级

// 尾插
void ListPush_back(LN* phead, Datetype x)
{//  防止为空链表assert(phead);// 尾插--升级版// ListInsert(phead, x);
}

 ✨删除结点

双向链表的删除操作分为 3 种情况： 

（1）头删
（2）尾删
（3）在指定 pos 位置删除

 ⚡头删

头删，即释 哨兵结点 的后一个结点，并建立 哨兵结点 与 被删除结点的后一个结点 之间的双向关系即可。

 📝 代码示例

// 头删
void ListPop_front(LN* phead)
{// 防止为空链表assert(phead);// 防止哨兵位的下一个节点为空assert(phead->next != phead);LN* front = phead->next;     // 记录头结点的后一个结点LN* newfront = front->next;  // 记录after结点的后一个结点/*建立头结点与newAfter结点之间的双向关系*/phead->next = newfront;newfront->prev = phead;free(front);  // 释放front节点// 头删--升级版// ListErase(phead->next);
}
⚡尾删 

尾删，即释放最后一个结点，并建立 哨兵结点 和 被删除结点的前一个结点 之间的双向关系即可。 

 📝 代码示例

// 尾删
void ListPop_back(LN* phead)
{// 防止为空链表assert(phead);// 防止哨兵位的下一个节点为空assert(phead->next != phead);LN* tail = phead->prev;     // 记录头结点的前一个结点--尾节点LN* newtail = tail->prev;   // 记录tail结点的前一个结点free(tail);  //释放tail节点tail = NULL;/*建立头结点与newtail结点之间的双向关系*/newtail->next = phead;phead->prev = newtail;// 尾删--升级版// ListErase(phead->prev);
}
 ⚡指定位置删除

删除指定 pos 位置的结点，这里不是删除 pos 前面的结点，也不是删除 pos 后面的结点，而是删除 pos 地址的结点。

同样，释放掉 pos 位置的结点后，建立该结点前一个结点和后一个结点之间的双向关系即可。

动图演示👇 

📝 代码示例 

// 删除pos位置上的节点
void ListErase(LN* pos)
{// 防止pos位置为空assert(pos);LN* posprev = pos->prev;   // 记录pos指向结点的前一个结点LN* posnext = pos->next;   // 记录pos指向结点的后一个结点free(pos);                 //free是把指针指向的节点还给操作系统pos = NULL;/*建立posprev结点与posnext结点之间的双向关系*/posprev->next = posnext;posnext->prev = posprev;
}
 ⚡删除升级

 同样，对于 头删 和 尾删 还是可以进行简化。

头删 实际上就是删除 哨兵结点 的 下一个结点。

📝 代码升级 

// 头删
void ListPop_front(LN* phead)
{// 防止为空链表assert(phead);// 防止哨兵位的下一个节点为空assert(phead->next != phead);// 头删--升级版// ListErase(phead->next);
}

尾删 实际上就是删除 哨兵结点 的 前一个结点。 

📝 代码升级 

// 尾删
void ListPop_back(LN* phead)
{// 防止为空链表assert(phead);// 防止哨兵位的下一个节点为空assert(phead->next != phead);// 尾删--升级版// ListErase(phead->prev);
}

✨查找元素

给定一个值，在链表中寻找与该值相同的结点，若找到了，则返回结点地址；

若没有找到，则返回空指针（NULL）。

📝 代码示例 

// 查找元素
LN* ListFind(LN* phead, Datetype x)
{// 防止为空链表assert(phead);LN* cur = phead->next;    // 从哨兵位的后一个结点开始查找while (cur != phead)      // 当cur指向头结点时，遍历完毕{if (cur->data == x){return cur;       // 返回目标结点的地址}cur = cur->next;}return NULL;              // 没有找到目标结点
}

 ✨链表判空

当链表的 头结点的前驱 或是 后驱 指向的是自己时，即 双向链表为空。

换句话说，当只有 哨兵结点 时，链表为空。

📝 代码示例 

// 链表判空  结果为1 是空   
bool ListEmpty(LN* phead)
{// 防止为空链表assert(phead);return phead->next == phead;    // 当链表中只有哨兵位时为空
}

 ✨获取链表中的元素个数

获取链表中的元素个数，即遍历一次链表，统计结点的个数（哨兵结点 不纳入总数）并返回即可。

 📝 代码示例

// 获取链表中元素的个数
int Listsize(LN* phead)
{// 防止为空链表assert(phead);int count = 0;  // 记录数据LN* cur = phead->next;  // 从头结点的后一个结点开始遍历while (cur != phead)    // 当cur指向头结点时，遍历完毕，头结点不计入总元素个数{count++;cur = cur->next;}return count;           //返回元素个数
}

 ✨销毁链表

 当链表使用完以后，要进行销毁。

销毁链表，从 哨兵结点 的 后一个结点 处开始向后遍历并释放结点，直到遍历到 哨兵结点 时，停止遍历并将 哨兵结点 也释放掉。

 📝 代码示例

// 销毁链表
void ListDestory(LN* phead)
{// 防止为空链表assert(phead);LN* cur = phead->next;   // 从哨兵位后一个结点开始释放空间while (cur != phead){LN* next = cur->next; // 释放之前先保存cur的后一个结点位置free(cur);cur = next;          // 把cur的下一个节点赋给cur}free(phead);           // 最后释放哨兵结点phead = NULL;
}

 五、带头双向循环链表的完整代码

✨ List.h 

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <assert.h>
#include <stdbool.h>// 带头双向循环链表     ---- list 的原型typedef int Datetype;  // 存储的数据类型// 定义  -- 带头双向循环链表 的节点 ----
typedef struct ListNode
{Datetype data;           // 数据域struct ListNode* next;   // 后驱指针struct ListNode* prev;   // 前驱指针
}LN;// 初始化链表
LN* BuyListNode(Datetype x);  // 新增一个节点
LN* ListInit();               // 带头双向循环链表的---初始化
void ListPrint(LN* phead);    // 打印链表// 插入节点
void ListPush_back(LN* phead, Datetype x);         // 尾插
void ListPush_front(LN* phead, Datetype x);        // 头插
void ListInsert(LN* pos, Datetype x);              // 在pos位置的前面插入// 删除节点
void ListPop_front(LN* phead);                     // 头删
void ListPop_back(LN* phead);                      // 尾删
void ListErase(LN* pos);                           // 删除pos位置上的节点// 空间操作
bool ListEmpty(LN* phead);                         // 链表判空
int Listsize(LN* phead);                           // 获取链表中元素的个数
void ListDestory(LN* phead);                       // 销毁链表
LN* ListFind(LN* phead, Datetype x);               // 查找元素

 ✨ List.c

#include "list.h"// 新增一个节点
LN* BuyListNode(Datetype x)
{// 创建一个新的节点LN* newnode = (LN*)malloc(sizeof(LN));// 判断这个节点是否创建成功if (newnode == NULL){printf("malloc fail\n");exit(-1);  // 终止程序}// 节点创建成功，开始给节点赋值newnode->data = x;newnode->next = NULL;newnode->prev = NULL;return newnode;
}// 带头双向循环链表的---初始化
LN* ListInit()
{// 创建一个头节点  这个头节点充当 --- 哨兵位---不存储有效数据LN* phead = BuyListNode(0);// 起始时只有头节点，让它的前驱和后继都指向自己// 使得链表一开始就满足循环phead->next = phead;phead->prev = phead;return phead;
}// 打印链表
// 注意：打印是从 哨兵位 的下一个节点开始打印
void ListPrint(LN* phead)
{//  防止为空链表assert(phead);printf("当前链表为：\n");printf("\n");printf("哨兵位<==>");// 从头结点的后一个结点开始打印LN* cur = phead->next;// 因为是循环链表 所以当 cur指针指向头节点的时候，说明已经打印结束while (cur != phead){printf("%d<==>", cur->data);cur = cur->next;}printf("NULL");printf("\n");printf("\n");
}// 尾插
void ListPush_back(LN* phead, Datetype x)
{//  防止为空链表assert(phead);LN* tail = phead->prev;  // 尾节点就是哨兵位的前驱指针LN* newnode = BuyListNode(x); // 申请一个结点，数据域赋值为x/*建立新结点与头结点之间的双向关系*/newnode->next = phead;phead->prev = newnode;/*建立新结点与tail结点之间的双向关系*/tail->next = newnode;newnode->prev = tail;// 尾插--升级版// ListInsert(phead, x);
}// 头插
void ListPush_front(LN* phead, Datetype x)
{//  防止为空链表assert(phead);LN* front = phead->next;  // 头节点就是哨兵位的后驱指针LN* newnode = BuyListNode(x); // 申请一个结点，数据域赋值为x/*建立新结点与头结点之间的双向关系*/phead->next = newnode;newnode->prev = phead;//建立新结点与beHind结点之间的双向关系newnode->next = front;front->prev = newnode;// 头插--升级版// ListInsert(phead->next, x);
}// 在pos位置的前面插入
void ListInsert(LN* pos, Datetype x)
{//  防止当前没有pos位置assert(pos);LN* posPrev = pos->prev; // 记录 pos 指向结点的前一个结点LN* newnode = BuyListNode(x); // 申请一个结点，数据域赋值为x/*建立新结点与posPrev结点之间的双向关系*/posPrev->next = newnode;newnode->prev = posPrev;/*建立新结点与pos指向结点之间的双向关系*/newnode->next = pos;pos->prev = newnode;
}// 头删
void ListPop_front(LN* phead)
{// 防止为空链表assert(phead);// 防止哨兵位的下一个节点为空assert(phead->next != phead);LN* front = phead->next;     // 记录头结点的后一个结点LN* newfront = front->next;  // 记录after结点的后一个结点/*建立头结点与newAfter结点之间的双向关系*/phead->next = newfront;newfront->prev = phead;free(front);  // 释放front节点// 头删--升级版// ListErase(phead->next);
} // 尾删
void ListPop_back(LN* phead)
{// 防止为空链表assert(phead);// 防止哨兵位的下一个节点为空assert(phead->next != phead);LN* tail = phead->prev;     // 记录头结点的前一个结点--尾节点LN* newtail = tail->prev;   // 记录tail结点的前一个结点free(tail);  //释放tail节点tail = NULL;/*建立头结点与newtail结点之间的双向关系*/newtail->next = phead;phead->prev = newtail;// 尾删--升级版// ListErase(phead->prev);
}// 删除pos位置上的节点
void ListErase(LN* pos)
{// 防止pos位置为空assert(pos);LN* posprev = pos->prev;   // 记录pos指向结点的前一个结点LN* posnext = pos->next;   // 记录pos指向结点的后一个结点free(pos);                 //free是把指针指向的节点还给操作系统pos = NULL;/*建立posprev结点与posnext结点之间的双向关系*/posprev->next = posnext;posnext->prev = posprev;
}// 链表判空  结果为1 是空   
bool ListEmpty(LN* phead)
{// 防止为空链表assert(phead);return phead->next == phead;    // 当链表中只有哨兵位时为空
}// 获取链表中元素的个数
int Listsize(LN* phead)
{// 防止为空链表assert(phead);int count = 0;  // 记录数据LN* cur = phead->next;  // 从头结点的后一个结点开始遍历while (cur != phead)    // 当cur指向头结点时，遍历完毕，头结点不计入总元素个数{count++;cur = cur->next;}return count;           //返回元素个数
}// 销毁链表
void ListDestory(LN* phead)
{// 防止为空链表assert(phead);LN* cur = phead->next;   // 从哨兵位后一个结点开始释放空间while (cur != phead){LN* next = cur->next; // 释放之前先保存cur的后一个结点位置free(cur);cur = next;          // 把cur的下一个节点赋给cur}free(phead);           // 最后释放哨兵结点phead = NULL;
}// 查找元素
LN* ListFind(LN* phead, Datetype x)
{// 防止为空链表assert(phead);LN* cur = phead->next;    // 从哨兵位的后一个结点开始查找while (cur != phead)      // 当cur指向头结点时，遍历完毕{if (cur->data == x){return cur;       // 返回目标结点的地址}cur = cur->next;}return NULL;              // 没有找到目标结点
}

✨ test.c

void menu()
{printf("*******************欢迎使用双向带头循环链表******************\n");printf("*************            1.   尾插            *************\n");printf("*************            2.   头插            *************\n");printf("*************            3.   尾删            *************\n");printf("*************            4.   头删            *************\n");printf("*************            5.查询pos位置        *************\n");printf("*************            6.在pos位前插入元素x  *************\n");printf("*************            7.删除pos位置的元素   *************\n");printf("*************            8.打印链表           ************* \n");printf("*************           -1.退出链表           ************* \n");printf("***********************************************************\n");LN* pList = ListInit();int option = -1;do{printf("请输入选项:> ");scanf("%d", &option);if (option == 1){int x = 0;printf("请输入你要尾插的元素:>");scanf("%d", &x);ListPush_back(pList, x);}else if (option == 2){int x = 0;printf("请输入你要头插的数字:>");scanf("%d", &x);ListPush_front(pList, x);}else if (option == 3){//尾删ListPop_back(pList);}else if (option == 4){//头删ListPop_front(pList);}else if (option == 5){int x = 0;printf("请输入你要查找的值x:>");scanf("%d", &x);LN* pos = ListFind(pList, x);if (pos != NULL){printf("存在数字%d\n", x);}else{printf("未找到数字%d\n", x);}}else if (option == 6){int x = 0;int y = 0;printf("请分别输入pos值x和pos前所插入的值y:>");scanf("%d %d", &x, &y);LN* pos = ListFind(pList, x);if (pos != NULL){ListInsert(pos, y);}else{printf("该链表不存在%d\n", x);}}else if (option == 7){int x = 0;printf("请输入要删除pos位置的值:>");scanf("%d", &x);LN* pos = ListFind(pList, x);ListErase(pos);}else if (option == 8){printf("\n");ListPrint(pList);}} while (option != -1);ListDestory(pList);}int main()
{menu();return 0;
}

 六、顺序表与链表的区别

 顺序表 与 链表 的优缺点：

优点缺点
顺序表1. 物理空间是连续的，方便用下标随机访问。
2. CPU高速缓存命中率会更高。		1. 由于需要物理空间连续，空间不够需要扩容。其次扩容机制还存在一定的空间浪费。
2. 头部或者中部插入、删除、挪动数据效率低 O(N)。
链表1、按需申请和释放空间。
2. 任意位置插入、删除数据效率高 O(1)。		1. 不支持下标的随机访问。有些算法不适合在它上面进行。如：二分、排序等

七、共勉

        以下就是我对 带头双向循环链表 的理解，如果有不懂和发现问题的小伙伴，请在评论区说出来哦，同时我还会继续更新对 C++ list 的理解，请持续关注我哦！！！     

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

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

相关文章

RS®ZNLE 矢量网络分析仪

RS®ZNLE 矢量网络分析仪

R&SZNLE 矢量网络分析仪 宽频率范围&#xff1a;100 kHz 至 20 GHz 基础测量任务 价值高 独立操作 基础网络分析应用的理想之选 R&SZNLE 矢量网络分析仪易于用户使用&#xff0c;适用于基础测量任务 闻名遐迩的优质设计、创新的用户界面以及紧凑尺寸使 R&…
阅读更多...
偏微分方程算法之椭圆型方程差分格式编程示例

偏微分方程算法之椭圆型方程差分格式编程示例

目录 一、示例1-五点菱形格式 1.1 C代码 1.2 计算结果 二、示例2-九点紧差分格式 2.1 C代码 2.2 计算结果 三、示例3-二阶混合边值 3.1 C代码 3.2 计算结果 本专栏对椭圆型偏微分方程的三种主要差分方法进行了介绍&#xff0c;并给出相应格式的理论推导过程。为加深对…
阅读更多...
力扣刷题--数组--第二天

力扣刷题--数组--第二天

今天仍然做二分查找相关的题目。先来回顾一下二分查找的方法和使用的条件。二分查找是在数组中查找目标值的一种方法&#xff0c;通过边界索引确定中间索引&#xff0c;判断中间索引处的元素值和目标值的大小&#xff0c;来不断缩小查找区间。使用二分查找有如下一些限制&#…
阅读更多...
C语言实战项目--贪吃蛇

C语言实战项目--贪吃蛇

贪吃蛇是久负盛名的游戏之一&#xff0c;它也和俄罗斯⽅块&#xff0c;扫雷等游戏位列经典游戏的行列。在编程语言的教学中&#xff0c;我们以贪吃蛇为例&#xff0c;从设计到代码实现来提升大家的编程能⼒和逻辑能⼒。 在本篇讲解中&#xff0c;我们会看到很多陌生的知识&…
阅读更多...
yum仓库

yum仓库

yum简介 1.基于RPM包构建的软件更新机制 2.可以自动解决依赖关系 3.所有软件包由yum软件仓库提供 yum工作原理 yum主配置文件 [rootlocalhost ~]# cat /etc/yum.conf [main] cachedir/var/cache/yum/$basearch/$releasever #yum下载的RPM包的缓存目录 $basearch代表硬件架…
阅读更多...
CANdela/Diva系列1--CANdela Studio的基本介绍

CANdela/Diva系列1--CANdela Studio的基本介绍

大家好&#xff0c;这个系列主要给大家介绍跟诊断相关的Vector 工具CANdela和Diva&#xff0c;首先介绍CANdela。 目录 1.CANdela的简介&#xff1a; 2.如何打开CANdela 工程&#xff1a; 3.CANdela工程的详细介绍&#xff1a; 3.1 工具栏的介绍&#xff1a; 3.2 工作树的…
阅读更多...
论文复现丨多车场带货物权重车辆路径问题：改进邻域搜索算法

论文复现丨多车场带货物权重车辆路径问题：改进邻域搜索算法

引言 本系列文章是路径优化问题学习过程中一个完整的学习路线。问题从简单的单车场容量约束CVRP问题到多车场容量约束MDCVRP问题&#xff0c;再到多车场容量时间窗口复杂约束MDCVRPTW问题&#xff0c;复杂度是逐渐提升的。 如果大家想学习某一个算法&#xff0c;建议从最简单…
阅读更多...
鸿蒙OpenHarmony【基于Hi3516DV300开发板（时钟应用开发）】

鸿蒙OpenHarmony【基于Hi3516DV300开发板（时钟应用开发）】

概述 本文将介绍如何快速搭建基于OpenHarmony标准系统&#xff08;Hi3516DV300开发板&#xff09;的应用开发环境&#xff0c;并基于一个时钟APP示例逐步展示应用的创建、开发、调试和安装等流程。示例代码可以通过本链接获取。 时钟App是一款显示实时时间的应用&#xff0c;…
阅读更多...
LeetCode 11—— 盛最多水的容器

LeetCode 11—— 盛最多水的容器

阅读目录 1. 题目2. 解题思路一3. 代码实现一4. 解题思路二5. 代码实现二 1. 题目 2. 解题思路一 暴力法&#xff0c;遍历所有可能的垂线对 ( i , j ) (i, j) (i,j)&#xff0c;求取最大面积&#xff1a; a r e a m i n ( h [ i ] , h [ j ] ) ∗ ( j − i ) area min(h[i]…
阅读更多...
从简单逻辑到复杂计算：感知机的进化与其在现代深度学习和人工智能中的应用（下）

从简单逻辑到复杂计算：感知机的进化与其在现代深度学习和人工智能中的应用（下）

文章目录 第一章&#xff1a;感知机的局限性1.1 异或门的挑战1.2 线性与非线性问题 第二章&#xff1a;多层感知机2.1 已有门电路的组合2.2 实现异或门 第三章&#xff1a;从与非门到计算机 文章文上下两节 从简单逻辑到复杂计算&#xff1a;感知机的进化与其在现代深度学习和人…
阅读更多...
【计算机科学速成课】笔记三——操作系统

【计算机科学速成课】笔记三——操作系统

文章目录 18.操作系统问题引出——批处理设备驱动程序多任务处理虚拟内存内存保护Unix 18.操作系统 问题引出—— Computers in the 1940s and early 50s ran one program at a time. 1940,1950 年代的电脑&#xff0c;每次只能运行一个程序 A programmer would write one at…
阅读更多...
QX-mini51学习---（2）点亮LED

QX-mini51学习---（2）点亮LED

目录 1什么是ed 2led工作参数 3本节相关原理图分析 4本节相关c 5实践 1什么是ed 半导体发光二极管&#xff0c;将电能转化为光能&#xff0c;耗电低&#xff0c;寿命长&#xff0c;抗震动 长正短负&#xff0c;贴片是绿点处是负极 2led工作参数 3本节相关原理图分析 当…
阅读更多...
【软测学习笔记】Python入门Day02

【软测学习笔记】Python入门Day02

&#x1f31f;博主主页&#xff1a;我是一只海绵派大星 &#x1f4da;专栏分类&#xff1a;软件测试笔记 &#x1f4da;参考教程&#xff1a;黑马教程❤️感谢大家点赞&#x1f44d;收藏⭐评论✍️ python安装 1、进入Python的官方下载页面&#xff1a; Download Python | Py…
阅读更多...
环保访谈|浙江双视专注红外机器视觉及智能化应用，保障安全生产

环保访谈|浙江双视专注红外机器视觉及智能化应用，保障安全生产

近期&#xff0c;中联环保圈希姐采访了浙江双视科技股份有限公司环保行业销售总监孙波&#xff0c;深入了解了双视科技的发展历程、产品和解决方案、合作流程、核心竞争力以及未来规划。 双视于2014年创立&#xff0c;专注于红外机器视觉、人工智能技术与应用开发&#xff0c;…
阅读更多...
《十八》QThread多线程组件

《十八》QThread多线程组件

本章将重点介绍如何运用QThread组件实现多线程功能。 多线程技术在程序开发中尤为常用&#xff0c;Qt框架中提供了QThread库来实现多线程功能。当你需要使用QThread时&#xff0c;需包含QThread模块&#xff0c;以下是QThread类的一些主要成员函数和槽函数。 成员函数/槽函数 …
阅读更多...
本地部署大模型ollama+docker+open WebUI/Lobe Chat

本地部署大模型ollama+docker+open WebUI/Lobe Chat

文章目录 大模型工具Ollama下载安装运行Spring Ai 代码测试加依赖配置写代码 ollama的web&Desktop搭建部署Open WebUI有两种方式Docker DesktopDocker部署Open WebUIDocker部署Lobe Chat可以配置OpenAI的key也可以配置ollama 大模型的选择 本篇基于windows环境下配置 大模型…
阅读更多...
HarmonyOS实战开发教程-如何开发一个2048游戏

HarmonyOS实战开发教程-如何开发一个2048游戏

今天为大家分享的是2048小游戏&#xff0c;先看效果图&#xff1a; 这个项目对于新手友友来说可能有一点难度&#xff0c;但是只要坚持看完一定会有收获。因为小编想分享的并不局限于ArkTs语言&#xff0c;而是编程思想。 这个游戏的基本逻辑是初始化一个4乘4的数组&#xff…
阅读更多...
论文笔记ColdDTA：利用数据增强和基于注意力的特征融合进行药物靶标结合亲和力预测

论文笔记ColdDTA：利用数据增强和基于注意力的特征融合进行药物靶标结合亲和力预测

ColdDTA发表在Computers in Biology and Medicine 的一篇一区文章 突出 • 数据增强和基于注意力的特征融合用于药物靶点结合亲和力预测。 • 与其他方法相比&#xff0c;它在 Davis、KIBA 和 BindingDB 数据集上显示出竞争性能。 • 可视化模型权重可以获得可解释的见解。 …
阅读更多...
并发编程之阻塞队列BlockingQueue实战及其原理分析

并发编程之阻塞队列BlockingQueue实战及其原理分析

1. 阻塞队列介绍 1.1 队列 是限定在一端进行插入&#xff0c;另一端进行删除的特殊线性表。 先进先出(FIFO)线性表。 允许出队的一端称为队头&#xff0c;允许入队的一端称为队尾。
阅读更多...
轻松应对数据恢复挑战：雷神笔记本，不同情况不同策略

轻松应对数据恢复挑战：雷神笔记本，不同情况不同策略

在数字化时代&#xff0c;数据无疑是我们生活中不可或缺的一部分。无论是重要的工作文件、珍贵的家庭照片&#xff0c;还是回忆满满的视频&#xff0c;一旦丢失&#xff0c;都可能给我们的生活带来诸多不便。雷神笔记本作为市场上备受欢迎的电脑品牌&#xff0c;用户在使用过程…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023