C++中的链表操作

最新推荐文章于 2025-06-30 10:05:11 发布
最新推荐文章于 2025-06-30 10:05:11 发布
阅读量1k 收藏 16
点赞数 16
CC 4.0 BY-SA版权
分类专栏： c++开发记录 文章标签： 开发语言 C++ 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44727517/article/details/146987843

在C++中，链表是一种常见的数据结构，它由一系列节点组成，每个节点包含数据部分和指向下一个节点的指针。C++标准库（STL）中提供了std::list和std::forward_list两种链表实现，分别对应双向链表和单向链表。此外，也可以通过手动实现链表来加深对链表的理解。

1. C++标准库中的链表

（1）std::list（双向链表）

std::list是C++标准库中的双向链表实现，每个节点包含指向前一个节点和后一个节点的指针。它支持高效的插入和删除操作，但随机访问效率较低。

  • 基本操作

    #include <iostream>
#include <list>

int main() {
    std::list<int> myList;

    // 插入元素
    myList.push_back(10); // 在链表尾部插入
    myList.push_front(20); // 在链表头部插入
    myList.insert(myList.begin() + 1, 30); // 在指定位置插入

    // 遍历链表
    for (int value : myList) {
        std::cout << value << " ";
    }
    std::cout << std::endl;

    // 删除元素
    myList.pop_back(); // 删除尾部元素
    myList.pop_front(); // 删除头部元素
    myList.erase(myList.begin() + 1); // 删除指定位置的元素

    // 遍历链表
    for (int value : myList) {
        std::cout << value << " ";
    }
    std::cout << std::endl;

    return 0;
}
（2）std::forward_list（单向链表）

std::forward_list是C++11引入的单向链表实现，每个节点只包含指向下一个节点的指针。它比std::list更轻量，但只能单向遍历。

  • 基本操作

    #include <iostream>
#include <forward_list>

int main() {
    std::forward_list<int> myList;

    // 插入元素
    myList.push_front(10); // 在链表头部插入
    myList.push_front(20);
    myList.insert_after(myList.begin(), 30); // 在指定位置插入

    // 遍历链表
    for (int value : myList) {
        std::cout << value << " ";
    }
    std::cout << std::endl;

    // 删除元素
    myList.pop_front(); // 删除头部元素
    myList.erase_after(myList.begin()); // 删除指定位置的元素

    // 遍历链表
    for (int value : myList) {
        std::cout << value << " ";
    }
    std::cout << std::endl;

    return 0;
}

2. 手动实现链表

手动实现链表可以帮助更好地理解链表的内部机制。以下是单向链表和双向链表的基本实现。

（1）单向链表
#include <iostream>

// 定义链表节点
struct Node {
    int data;
    Node* next;

    Node(int value) : data(value), next(nullptr) {}
};

// 定义链表类
class LinkedList {
private:
    Node* head;

public:
    LinkedList() : head(nullptr) {}

    // 插入元素到链表尾部
    void append(int value) {
        Node* newNode = new Node(value);
        if (head == nullptr) {
            head = newNode;
        } else {
            Node* current = head;
            while (current->next != nullptr) {
                current = current->next;
            }
            current->next = newNode;
        }
    }

    // 插入元素到链表头部
    void prepend(int value) {
        Node* newNode = new Node(value);
        newNode->next = head;
        head = newNode;
    }

    // 删除元素
    void remove(int value) {
        if (head == nullptr) return;

        if (head->data == value) {
            Node* temp = head;
            head = head->next;
            delete temp;
            return;
        }

        Node* current = head;
        while (current->next != nullptr && current->next->data != value) {
            current = current->next;
        }

        if (current->next != nullptr) {
            Node* temp = current->next;
            current->next = temp->next;
            delete temp;
        }
    }

    // 遍历链表
    void print() const {
        Node* current = head;
        while (current != nullptr) {
            std::cout << current->data << " ";
            current = current->next;
        }
        std::cout << std::endl;
    }

    // 析构函数，释放链表内存
    ~LinkedList() {
        Node* current = head;
        while (current != nullptr) {
            Node* temp = current;
            current = current->next;
            delete temp;
        }
    }
};

int main() {
    LinkedList list;

    list.append(10);
    list.append(20);
    list.prepend(5);

    list.print(); // 输出：5 10 20

    list.remove(10);
    list.print(); // 输出：5 20

    return 0;
}
（2）双向链表
#include <iostream>

// 定义链表节点
struct Node {
    int data;
    Node* next;
    Node* prev;

    Node(int value) : data(value), next(nullptr), prev(nullptr) {}
};

// 定义链表类
class DoublyLinkedList {
private:
    Node* head;
    Node* tail;

public:
    DoublyLinkedList() : head(nullptr), tail(nullptr) {}

    // 插入元素到链表尾部
    void append(int value) {
        Node* newNode = new Node(value);
        if (head == nullptr) {
            head = newNode;
            tail = newNode;
        } else {
            tail->next = newNode;
            newNode->prev = tail;
            tail = newNode;
        }
    }

    // 插入元素到链表头部
    void prepend(int value) {
        Node* newNode = new Node(value);
        if (head == nullptr) {
            head = newNode;
            tail = newNode;
        } else {
            newNode->next = head;
            head->prev = newNode;
            head = newNode;
        }
    }

    // 删除元素
    void remove(int value) {
        Node* current = head;
        while (current != nullptr && current->data != value) {
            current = current->next;
        }

        if (current == nullptr) return;

        if (current->prev != nullptr) {
            current->prev->next = current->next;
        } else {
            head = current->next;
        }

        if (current->next != nullptr) {
            current->next->prev = current->prev;
        } else {
            tail = current->prev;
        }

        delete current;
    }

    // 遍历链表
    void print() const {
        Node* current = head;
        while (current != nullptr) {
            std::cout << current->data << " ";
            current = current->next;
        }
        std::cout << std::endl;
    }

    // 析构函数，释放链表内存
    ~DoublyLinkedList() {
        Node* current = head;
        while (current != nullptr) {
            Node* temp = current;
            current = current->next;
            delete temp;
        }
    }
};

int main() {
    DoublyLinkedList list;

    list.append(10);
    list.append(20);
    list.prepend(5);

    list.print(); // 输出：5 10 20

    list.remove(10);
    list.print(); // 输出：5 20

    return 0;
}

总结

  • 标准库链表：std::list和std::forward_list提供了丰富的功能和高效的插入删除操作，适合大多数应用场景。

  • 手动实现链表：通过手动实现链表，可以加深对链表内部机制的理解，例如节点的创建、插入、删除和内存管理等。

c++中的链表
liujassin的博客
06-09 661
本文主要简介了链表的原理在c++中的主要作用和使用方法和一些经典的例题
C++链表
weixin_44540140的博客
06-27 1145
使用C++存储大量的数据时,正常的方法是通过数组,但数组的长度是需要提前指定的,而且在创建时需要连续的空间来创建,所以我们定义了一种全新的存储数据的结构,链表. 链表相较于数组,其无需指定长度,可以动态申请内存,且不占用连续的存储空间,还是非常好用的 首先需要创建一个类,此类用于存储数据,然后在这个类中添加一个此类型的指针,然后添加一些方法用于操作这个链表,具体效果如下 #pragma once class Goods { //访问权限,公共 public: //友元 可以在这个类的外部获取这个
C++STL容器：链表介绍与使用
最新发布
weixin_54358182的博客
06-30 923
链表是一种通过指针串联的数据结构，分为单向链表、双向链表和循环链表三种类型。单向链表节点包含数据域和后继指针，双向链表节点还包含前驱指针，循环链表则首尾相连形成闭环。链表的优势在于动态内存分配和高效插入/删除（O(1)时间复杂度），但随机访问效率较低（O(n)）。在C++中，可以通过手动定义链表节点结构或使用STL的list（双向链表）和forward_list（单向链表）来实现。list容器支持多种构造方式，提供头尾插入/删除、迭代器访问、排序等操作，并具有高效的splice节点转移方法。
C++ 链表
LYSM
02-05 464
代码： // Test_Console_3.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。 // #include <iostream> #include<cstdlib> using namespace std; // 链表结构体 typedef struct listpoint { int data; // 数据 li...
C++ STL 之 list
weixin_30951743的博客
05-25 334
#include <list> #include <iostream> using namespace std; // 打印list元素 void PrintList(list<int>& L) { for (list<int>::iterator it = L.begin(); it != L.end(...
C++中链表操作实例分析
08-30
C++中链表操作实例分析 在C++中，链表是一种常见的重要数据结构。它是动态地进行存储分配的一种结构，可以根据需要开辟内存单元。链表有一个“头指针”变量，以head表示，它存放一个地址。该地址指向一个元素。 ...
c++双向链表操作示例(创建双向链、双向链表中查找数据、插入数据等)
12-25
所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。（1）定义双向链表的基本结构 代码如下:typedef struct _DOUBLE_LINK_NODE { int data; struct ...
c++基础知识——STL之链表
热门推荐
qq_59931372的博客
05-05 1万+
STLzhi链表，想学习c++ 的朋友可以看过来了，带你学会c++中的链表;
C++之STL—List 链表
QoQ_____________的博客
09-24 455
结点的组成：一个是存储数据元素的**数据域**，另一个是存储下一个结点地址的**指针域**- 重新指定个数 --- resize。* 头插 --- push_front。- 判断是否为空 --- empty。* 尾插 --- push_back。* 头删 --- pop_front。- 返回元素个数 --- size。* 尾删 --- pop_back。* 插入 --- insert。* 删除 --- erase。* 清空 --- clear。List 赋值和交换。
c语言通用链表库
02-02
本代码提供采用c语言编写链表的使用源码，有创建、初始化、删除、插入、查找等等功能
【C/C++学院】0802-链式栈/链表队列以及优先队列/封装链表库
weixin_34234823的博客
09-13 113
链式栈 // stacklinknode.h #define datatype int struct stacknode { int num;//编号 datatype data;//数据 struct stacknode *pNext;//指针域 }; typedef struct stacknode StackNode;//简化 S...
【C++】STL | list (链表)详解及重要函数的实现
2302_80023639的博客
08-07 2097
相比于vector和string，list这个迭代器可就开始上强度了其主要的强度在于：vector和string都是开辟的一段连续的空间，所以这两个的迭代器用原生指针就可以实现但是list不一样，list的空间是分散的，只有通过每个节点里的next指针才能找到下一个节点，还有就是实现const迭代器于普通迭代器两个版本的时候，需要在模板参数上动点手脚，这也是一个相对晦涩的地方kw=list到这里我们的list底层实现相关内容就结束啦(～￣▽￣)～
C++:线上课程1_26（STL链表）
小柒的秃头之路
03-17 316
文章目录一、String二、STL链表1.链表2.迭代器示例 一、String realloc函数使用 strcpy函数使用 strcat函数使用 #define _CRT_SECURE_NO_WARNINGS #include"stdio.h" #include<iostream> #include<stdlib.h> #include<assert.h> #include<string.h> #include<vector> #include&
简述C++STL-链表
ikkkkkkkl的博客
11-23 1589
/ 在指定位置插入一个区间的元素，返回指向第一个插入元素的迭代器。// 在指定位置插入一个元素，返回指向插入元素的迭代器。// 删除指定区间的元素，返回下一个有效的迭代器。// 删除链表中满足条件的元素，参数_Pred是一元函数。
如何使用C++实现链表
Chaoskd的博客
09-17 377
C++实现单链表 如何使用C++实现单链表 我按照书里代码想实现单链表，但是为什么会报错？
【C++ STL】细数C++ STL 的那些事---List（双向链表）
java开发指南博客 【转载】
04-08 224
一，概述 List将元素按顺序储存在链表中.与向量(vectors)相比,它允许快速的插入和删除，但是随机访问却比较慢。 list 不仅是一个双向链表，而且是一个环状双向链表 二，使用 #include &lt;list&gt; using namespace std; 注意：list是一个“前闭后开”的区间，即 list&lt;int&gt; lt(10,6...
【库】c实现链表
学习与研究
07-21 3034
________________________c_list.h__________________#ifndef C_LIST_H#define C_LIST_H#ifndef ERR#define ERR -1#define OK 1#endif#ifndef MAX#define MAX 100#define MIN 0#endiftypedef
C++实现链表操作：创建、插入、删除
"这篇资源是关于使用C++实现链表操作的代码示例，包括创建链表、计算链表长度、头插入、尾插入、中间插入以及删除头节点、删除尾节点和删除指定元素等功能。" 在C++编程中，链表是一种非常重要的数据结构，它不像...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

这个懒人

感谢打赏

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值