C++ 单链表、双链表和循环链表

于 2024-09-29 14:28:46 发布
阅读量569 收藏 7
点赞数 24
文章标签： c++ 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_50373827/article/details/142634148
版权
特性/操作单链表 (Singly Linked List)双链表 (Doubly Linked List)循环链表 (Circular Linked List)
节点结构数据 + 指向下一个节点指针数据 + 指向前一个节点指针 + 指向下一个节点指针数据 + 指向下一个节点指针
头指针指向第一个节点指向第一个节点指向第一个节点
遍历方向单向遍历双向遍历从头节点开始，循环遍历
插入操作在头部或尾部插入在头部或尾部插入在尾部插入，指向头节点
删除操作需要找到前一个节点直接访问前后节点需调整指针保持循环结构
内存管理节点删除需手动管理节点删除需手动管理节点删除需手动管理
应用场景动态数据存储，栈浏览器前进后退功能，音乐播放器游戏回合制，任务调度
优缺点- 内存利用高
- 插入/删除简单
- 难以逆向遍历		- 支持双向遍历
- 删除操作方便
- 内存开销大		- 节省空间
- 循环结构适合循环任务
- 删除操作需注意循环

操作示例

操作单链表例子双链表例子循环链表示例
插入insert(30)
头部: 30 -> 10 -> 20		insert(30)
头部: 30 <-> 10 <-> 20		insert(30)
尾部: 10 -> 20 -> 30 -> 头
删除remove(10)
结果: 20		remove(20)
结果: 10 <-> 30		remove(10)
结果: 20 -> 30 -> 头

一、单链表（Singly Linked List）

1. 定义

单链表是一种线性数据结构，由一系列节点构成。每个节点包含数据部分和指向下一个节点的指针，最后一个节点的指针指向 nullptr。

2. 原理

  • 节点结构：每个节点包含数据和指向下一个节点的指针。
  • 头指针：链表的起始点，通过它访问其他节点。

3. 操作

  • 插入：在链表头部或尾部插入新节点。
  • 删除：根据值删除节点，需调整指针。
  • 遍历：从头节点开始，依次访问每个节点。

4. 应用场景

  • 动态数据存储（如购物车）。
  • 实现栈（后进先出）。

5. 示例代码

#include <iostream>

struct Node {
    int data;         // 节点数据
    Node* next;      // 指向下一个节点的指针
};

class SinglyLinkedList {
private:
    Node* head;      // 链表头指针

public:
    SinglyLinkedList() : head(nullptr) {} // 初始化头指针
    ~SinglyLinkedList();                    // 析构函数
    void insert(int value);                 // 插入节点
    void remove(int value);                 // 删除节点
    void display() const;                   // 显示链表内容
};

// 析构函数，释放链表内存
SinglyLinkedList::~SinglyLinkedList() {
    Node* current = head;
    while (current) {
        Node* next = current->next; // 保存下一个节点
        delete current;              // 删除当前节点
        current = next;              // 移动到下一个节点
    }
}

// 在链表头插入新节点
void SinglyLinkedList::insert(int value) {
    Node* newNode = new Node{value, head}; // 创建新节点
    head = newNode;                        // 更新头指针
}

// 删除指定值的节点
void SinglyLinkedList::remove(int value) {
    if (!head) return; // 链表为空直接返回
    if (head->data == value) { // 如果要删除的是头节点
        Node* temp = head;
        head = head->next; // 更新头指针
        delete temp;       // 删除节点
        return;
    }
    Node* current = head; // 当前节点
    while (current->next && current->next->data != value) {
        current = current->next; // 查找节点
    }
    if (current->next) { // 找到要删除的节点
        Node* temp = current->next;
        current->next = current->next->next; // 调整指针
        delete temp;                          // 删除节点
    }
}

// 显示链表内容
void SinglyLinkedList::display() const {
    Node* current = head; // 当前节点
    while (current) {
        std::cout << current->data << " "; // 输出节点数据
        current = current->next;            // 移动到下一个节点
    }
    std::cout << std::endl; // 输出换行
}

int main() {
    SinglyLinkedList sll; // 创建单链表实例
    sll.insert(10);       // 插入数据
    sll.insert(20);
    sll.display();        // 输出: 20 10
    sll.remove(10);      // 删除数据
    sll.display();        // 输出: 20
    return 0;             // 程序结束
}

插入操作

  • 在链表头插入：

  • 插入 30
    原链表: 10 -> 20 -> nullptr
    插入后: 30 -> 10 -> 20 -> nullptr

  • 在链表尾插入：

  • 插入 30
    原链表: 10 -> 20 -> nullptr
    插入后: 10 -> 20 -> 30 -> nullptr

删除操作

  • 删除头节点：

  • 删除 10
    原链表: 10 -> 20 -> nullptr
    删除后: 20 -> nullptr

  • 删除中间节点：

  • 删除 20
    原链表: 10 -> 20 -> 30 -> nullptr
    删除后: 10 -> 30 -> nullptr
     

二、双链表（Doubly Linked List）

1. 定义

双链表是一种线性数据结构，每个节点包含数据、指向下一个节点的指针和指向前一个节点的指针。

2. 原理

  • 节点结构：每个节点包含前后指针。
  • 双向遍历：可以从任一节点向前或向后遍历。

3. 操作

  • 插入：在链表头部或尾部插入新节点，需调整前后指针。
  • 删除：根据值删除节点，需调整前后指针。
  • 遍历：可以双向遍历链表。

4. 应用场景

  • 浏览器的前进和后退功能。
  • 音乐播放器的播放列表。

5. 示例代码

#include <iostream>

struct DNode {
    int data;         // 节点数据
    DNode* next;     // 指向下一个节点的指针
    DNode* prev;     // 指向前一个节点的指针
};

class DoublyLinkedList {
private:
    DNode* head;      // 链表头指针

public:
    DoublyLinkedList() : head(nullptr) {} // 初始化头指针
    ~DoublyLinkedList();                    // 析构函数
    void insert(int value);                 // 插入节点
    void remove(int value);                 // 删除节点
    void display() const;                   // 显示链表内容
};

// 析构函数，释放链表内存
DoublyLinkedList::~DoublyLinkedList() {
    DNode* current = head;
    while (current) {
        DNode* next = current->next; // 保存下一个节点
        delete current;               // 删除当前节点
        current = next;               // 移动到下一个节点
    }
}

// 在链表尾部插入新节点
void DoublyLinkedList::insert(int value) {
    DNode* newNode = new DNode{ value, nullptr, nullptr }; // 创建新节点
    if (!head) { // 链表为空
        head = newNode; // 更新头指针
        return;
    }
    DNode* temp = head; // 当前节点
    while (temp->next) {
        temp = temp->next; // 遍历到链表尾部
    }
    temp->next = newNode; // 将新节点连接到尾部
    newNode->prev = temp; // 更新新节点的前指针
}

// 删除指定值的节点
void DoublyLinkedList::remove(int value) {
    if (!head) return; // 链表为空直接返回
    if (head->data == value) { // 如果要删除的是头节点
        DNode* temp = head;
        head = head->next; // 更新头指针
        if (head) head->prev = nullptr; // 更新新头节点的前指针
        delete temp; // 删除节点
        return;
    }
    DNode* current = head; // 当前节点
    while (current && current->data != value) {
        current = current->next; // 查找节点
    }
    if (current) { // 找到要删除的节点
        if (current->next) current->next->prev = current->prev; // 更新后继节点的前指针
        if (current->prev) current->prev->next = current->next; // 更新前驱节点的后指针
        delete current; // 删除节点
    }
}

// 显示链表内容
void DoublyLinkedList::display() const {
    DNode* current = head; // 当前节点
    while (current) {
        std::cout << current->data << " "; // 输出节点数据
        current = current->next;            // 移动到下一个节点
    }
    std::cout << std::endl; // 输出换行
}

int main() {
    DoublyLinkedList dll; // 创建双链表实例
    dll.insert(1);        // 添加到播放列表
    dll.insert(2);
    dll.insert(3);
    dll.display();        // 输出: 1 2 3
    dll.remove(2);       // 从播放列表中移除
    dll.display();        // 输出: 1 3
    return 0;             // 程序结束
}

插入操作

  • 在链表头插入：

  • 插入 30
    原链表: 10 <-> 20
    插入后: 30 <-> 10 <-> 20

  • 在链表尾插入：

  • 插入 30
    原链表: 10 <-> 20
    插入后: 10 <-> 20 <-> 30

删除操作

  • 删除头节点：

  • 删除 10
    原链表: 10 <-> 20
    删除后: 20

  • 删除中间节点：

  • 删除 20
    原链表: 10 <-> 20 <-> 30
    删除后: 10 <-> 30

三、循环链表（Circular Linked List）

1. 定义

循环链表是一种特殊的链表，最后一个节点的指针指向头节点，形成一个循环结构。

2. 原理

  • 节点结构：与单链表相似，但最后一个节点的指针指向头节点。
  • 遍历：可以无限循环遍历链表。

3. 操作

  • 插入：在链表尾部插入新节点，需确保新节点指向头节点。
  • 删除：根据值删除节点，需调整指针以保持循环结构。
  • 遍历：从头节点开始，直到回到头节点。

4. 应用场景

  • 游戏中的回合制。
  • 任务调度。

5. 示例代码

#include <iostream>

struct CNode {
    int data;         // 节点数据
    CNode* next;     // 指向下一个节点的指针
};

class CircularLinkedList {
private:
    CNode* head;      // 链表头指针

public:
    CircularLinkedList() : head(nullptr) {} // 初始化头指针
    ~CircularLinkedList();                     // 析构函数
    void insert(int value);                    // 插入节点
    void remove(int value);                    // 删除节点
    void display() const;                      // 显示链表内容
};

// 析构函数，释放链表内存
CircularLinkedList::~CircularLinkedList() {
    if (!head) return; // 链表为空直接返回
    CNode* current = head; // 当前节点
    CNode* nextNode;        // 下一个节点
    do {
        nextNode = current->next; // 保存下一个节点
        delete current;           // 删除当前节点
        current = nextNode;       // 移动到下一个节点
    } while (current != head);    // 遍历至回到头节点
}

// 在链表尾部插入新节点
void CircularLinkedList::insert(int value) {
    CNode* newNode = new CNode{ value, nullptr }; // 创建新节点
    if (!head) { // 如果链表为空
        head = newNode; // 更新头指针
        newNode->next = head; // 新节点指向自身
        return;
    }
    CNode* temp = head; // 当前节点
    while (temp->next != head) { // 遍历到链表尾部
        temp = temp->next; // 移动到下一个节点
    }
    temp->next = newNode; // 将新节点连接到尾部
    newNode->next = head; // 新节点指向头节点，形成循环
}

// 删除指定值的节点
void CircularLinkedList::remove(int value) {
    if (!head) return; // 链表为空直接返回

    CNode* current = head; // 当前节点
    CNode* prev = nullptr; // 前驱节点

    if (head->data == value) { // 如果要删除的是头节点
        if (head->next == head) { // 如果链表只有一个节点
            delete head; // 删除节点
            head = nullptr; // 更新头指针
            return;
        }
        while (current->next != head) { // 找到尾节点
            current = current->next; // 移动到下一个节点
        }
        CNode* temp = head; // 保存头节点
        head = head->next; // 更新头指针
        current->next = head; // 更新尾节点的指针
        delete temp; // 删除节点
        return;
    }

    do {
        prev = current; // 记录前驱节点
        current = current->next; // 移动到下一个节点
    } while (current != head && current->data != value); // 查找值

    if (current != head) { // 找到要删除的节点
        prev->next = current->next; // 删除节点
        delete current; // 删除节点
    }
}

// 显示链表内容
void CircularLinkedList::display() const {
    if (!head) return; // 如果链表为空，直接返回

    CNode* current = head; // 当前节点
    do {
        std::cout << current->data << " "; // 输出节点数据
        current = current->next; // 移动到下一个节点
    } while (current != head); // 遍历至回到头节点
    std::cout << std::endl; // 输出换行
}

int main() {
    CircularLinkedList cll; // 创建循环链表实例
    cll.insert(1); // 模拟游戏回合
    cll.insert(2);
    cll.insert(3);
    cll.display(); // 输出: 1 2 3
    cll.remove(2); // 移除玩家 2
    cll.display(); // 输出: 1 3
    return 0; // 程序结束
}
 

插入操作

  • 在链表尾插入：
  • 插入 30
    原链表: 10 -> 20 -> 头节点(10)
    插入后: 10 -> 20 -> 30 -> 头节点(10)

删除操作

  • 删除头节点：

  • 删除 10
    原链表: 10 -> 20 -> 30 -> 头节点(10)
    删除后: 20 -> 30 -> 头节点(20)

  • 删除中间节点：

  • 删除 20
    原链表: 10 -> 20 -> 30 -> 头节点(10)
    删除后: 10 -> 30 -> 头节点(10)
     

Qfuuu
关注
单链表、双链表、循环链表简介
z2141830440的博客
03-10 771
对于一个链表，是由一系列不必在内存中相连的结构组成，每一个结构均含有表元素和指向包含该元素下一个表结构的指针（我们称之为Next指针）,它们也叫数据域和指针域。最后一个表结构的Next指针指向NULL，ANSI C规定NULL为零。（图1-2中箭头表示的就是Next指针）
从头详细了解单链表、双向链表，循环链表的构建及操作【c++】
weixin_60634144的博客
05-15 1299
目录 引入 单链表 创建链表的准备 链表的创建 链表的插入 链表的删除 举例 插入节点、按数据删除节点、打印链表数据 的代码实现 双向链表 循环链表 引入 自引用结构体： 即在结构体中包含了一个指向与其类型相同的结构体的指针成员。例如下面的例子： struct node{ int data; struct node* nextPtr } 定义了一个 struct node ，其中包含一个数据成员 data 和一个指针成员 nextPtr，而nextPt.
单链表、双链表、循环链表
ckk727的博客
09-20 2578
这学期的数据结构课有讲到链表，所以再来温故一下，毕竟温故知新嘛。 链表与数组的区别 链表和数组都是线性表，两者区别如下： 数组静态分配内存，链表动态分配内存；更进一步说就是数组不易拓展，但链表易拓展。 数组在内存中连续，链表不连续；更进一步说就是数组可能会造成内存浪费，但链表的内存利用率高； 数组利用下标定位元素，时间复杂度为O(1)，链表在最坏情况下是O(n)；即在随机性查找上数组比链表更...
数组、单链表和双链表介绍以及双向链表的C/C++实现
SB202211的博客
07-19 778
节点10"的后继节点是"节点20"(数据为10的节点)，"节点20"的前继节点是"节点10"；表头为空，表头的后继节点是"节点10"(数据为10的节点)，"节点10"的后继节点是"节点20"(数据为10的节点)，..."节点20"的后继节点为"节点30"，而"节点30"的后继节点为"节点40"。"节点10"的后继节点为"节点15"，而"节点15"的后继节点为"节点20"。"节点10"的后继节点为"节点20"，"节点20"的前继节点为"节点10"。"节点10"的后继节点为"节点20"。......
一文搞懂链表结构（单链表、双链表、循环链表、删除、添加、内存结构）
w20001118的博客
07-24 784
什么是链表，链表是一种通过指针串联在一起的线性结构，每一个节点由两部分组成，一个是数据域一个是指针域（存放指向下一个节点的指针），最后一个节点的指针域指向null（空指针的意思）。链接的入口节点称为链表的头结点也就是head。所以链表中的节点在内存中不是连续分布的，而是散乱分布在内存中的某地址上，分配机制取决于操作系统的内存管理。每一个节点有两个指针域，一个指向下一个节点，一个指向上一个节点。数组是在内存中是连续分布的，但是链表在内存中可不是连续分布的。链表是通过指针域的指针链接在内存中各个节点。...
C++ 单向/双向链表
qq_37164776的博客
01-07 227
顺序表的链式表示形式又分为了：单链表、双向链表、单循环链表、双向循环链表几种。优点：插入或删除元素时很方便，使用灵活，存储空间利用率高。缺点：存储密度小（
数组实现单链表和双链表
_featherbrain的博客
12-07 1369
数组实现单链表和双链表的细节
c/c++ 循环单链表变循环双链表
weixin_40971308的博客
05-13 2886
最近遇到了一个作业题目是：建立一个循环单链表，其节点有 prior，data 和 next 三个域，其中 data 为数据域，存放元素的有效信息，next 域为指针域，指向后继节点，prior 为指针域，它的值为 NULL。编写一个算法将此表改为循环双链表。看了一下感觉不难，好，开始动手。建立链表结构 链表在c语言建立是通过结构体建立，通过在结构体内部建立其结构体本身的指针类型指向下一个节点来实现...
【C++实现循环单链表】
wddkxg的博客
03-02 437
学习循环单链表的结构、和普通单链表的区别以及循环单链表的实现 c++实现单链表
链表 - 双链表/循环链表/静态链表
Mafia的博客
03-09 1752
双链表/循环链表/静态链表双链表初始化插入删除双链表的遍历循环链表插入删除静态链表定义静态链表基本操作 双链表 单链表无法逆向检索，有时候不太方便； 使用双链表，可进可退，存储密度比单链表低一些，因为一个节点除了后继指针next还多了一个前驱指针prior typedef struct DNode{ //定义双链表节点类型 ElemType data; //数据域 struct DNode *prior, *next; //前驱和后继指针 }DNode, *DLinklist; 初始化 带头结点：
深入解析C++的循环链表与双向链表设计的API实现
09-02
在C++编程中，循环链表和双向链表是两种重要的数据结构，它们在处理动态数据集合时提供了灵活且高效的方式。循环链表是单链表的一种变体，它的最后一个节点指向链表的第一个节点，形成了一个逻辑上的环。双向链表则...
单链表循环链表多项式及其相加双向链表稀疏矩阵PPT学习教案.pptx
10-07
总结起来，这个PPT学习教案深入浅出地介绍了单链表、循环链表、多项式相加、双向链表和稀疏矩阵的概念，以及如何用C++实现链表的节点类，这对于理解和操作这些数据结构至关重要，是计算机科学教育的基础内容。
【数据结构和算法】动图详解，链表（单链表/双链表……）（实例讲解）
热门推荐
Linux猿
09-22 1万+
???? 作者：Linux猿 ???? 简介：CSDN博客专家????，华为云享专家????，C/C++、面试、刷题、算法尽管咨询我，关注我，有问题私聊！ ???? 关注专栏：C/C++面试通关集锦（优质好文持续更新中……）???? 目录 一、单链表 1.1 插入节点 1.2 删除结点 二、双链表 2.1 插入节点 2.2 删除节点 三、单向循环链表 3.1 插入节点 3.2 删除结点 四、双向循环链表 4.1 插入节点 4.2 删除节点 五、静态链表 六、实战讲解 6.
C++ 异步编程中：future与promise、packaged_task、async
zxf347085420的博客
09-23 992
std::launch::async | std::launch::deferred参数：是默认行为(可省略)。=》std::async真的是来帮忙的，你不用再想到底该怎么用std::future、std::promise和 std::packaged_task了，在已经有了td::future、std::promise和std::packaged_task的情况下，实现异步或多线程间通信，事实上std::promise::set_xxx函数会改变std::promise的状态为ready，
【C++】拆分详解 - string类
bubble_shadow的博客
09-23 1006
string类的文档介绍注：此处及下文部分，蓝色下划线标识文本均为超链接，点击即可跳转字符串是表示字符序列的类标准的字符串类提供了对此类对象的支持，其接口类似于标准字符容器的接口，但添加了专门用于操作单字节字符字符串的设计特性。string类是使用char(即作为它的字符类型，使用它的默认char_traits和分配器类型(关于模板的更多信息，请参阅basic_string)。
pyqt瀑布流布局
weixin_54217201的博客
09-21 482
最近研究瀑布流布局，发现都是收费的，所以只能自己写算法写布局。所以啥都不说直接上代码。
189. 轮转数组（C++）
weixin_45813121的博客
09-25 397
给定一个整数数组nums，将数组中的元素向右轮转k个位置，其中k是非负数。
c++ 使用 Graham 扫描的凸包（Convex Hull using Graham Scan）
csdn_aspnet的专栏
09-26 1075
对于剩余的点，我们跟踪最近的三个点，并找到它们形成的角度。如果这些点的方向（按相同顺序考虑它们）不是逆时针的，我们丢弃 c，否则我们保留它。因此，第六步逐个处理点需要 O(n) 时间，假设堆栈操作需要 O(1) 时间。总体复杂度为 O(n) + O(nLogn) + O(n) + O(n)，即 O(nLogn)。在每个步骤中，算法都会检查添加到凸包中的最后两个点是否形成右转。格雷厄姆扫描算法是一种简单而有效的算法，用于计算一组点的凸包。凸包用于各种计算几何算法，例如查找最近的点对和计算一组点的直径。
【C++】红黑树的封装——同时实现map和set
最新发布
Mesar的博客
09-27 611
学习map和set，深入了解底层，通过模拟实现，学习高效数据结构与容器的关系，也帮助我们更好了解和使用容器
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值