C++入门-list

最新推荐文章于 2024-10-29 10:26:02 发布
最新推荐文章于 2024-10-29 10:26:02 发布
阅读量1.5k 收藏 37
点赞数 37
文章标签： c++ list 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Choulqt/article/details/138050074
版权

大家好啊，一周没见了。我们也闲话少说，直接发车，今天来聊聊C++中的list ！
在这里插入图片描述

1. list的介绍

在C++标准库中，std::list是一个双向链表容器，它提供了高效的插入和删除操作，但访问元素的效率较低。std::list的特点包括：

  • 元素存储在链表中，插入和删除操作的时间复杂度为O(1)；
  • 不支持随机访问，需要通过迭代器进行遍历；
  • 支持在任何位置插入和删除元素，不会造成内存的重新分配。

演示代码

下面是一个简单的示例代码，演示如何使用std::list：

#include <iostream>
#include <list>

int main() {
    // 创建一个空的list
    std::list<int> mylist;

    // 在list末尾插入元素
    mylist.push_back(1);
    mylist.push_back(2);
    mylist.push_back(3);

    // 在list开头插入元素
    mylist.push_front(0);

    // 遍历list并输出元素
    for (auto it = mylist.begin(); it != mylist.end(); ++it) {
        std::cout << *it << " ";
    }

    return 0;
}

在上面的代码中，我们首先创建了一个空的std::list对象mylist，然后使用push_back在list的末尾插入了三个元素，使用push_front在list的开头插入了一个元素。最后，我们通过迭代器it遍历list，并输出元素的值。

std::list是一个非常灵活的容器，适合在需要频繁插入和删除操作的场景中使用。

1.2 list的使用

创建list并插入元素

#include <iostream>
#include <list>

int main() {
    // 创建一个空的list
    std::list<int> mylist;

    // 在list末尾插入元素
    mylist.push_back(1);
    mylist.push_back(2);
    mylist.push_back(3);

    // 在list开头插入元素
    mylist.push_front(0);

    // 遍历list并输出元素
    for (auto it = mylist.begin(); it != mylist.end(); ++it) {
        std::cout << *it << " ";
    }

    return 0;
}

在上面的示例中，我们创建了一个空的std::list对象mylist，然后使用push_back在list的末尾插入了三个元素，使用push_front在list的开头插入了一个元素。最后，通过迭代器遍历list并输出元素的值。

删除元素

#include <iostream>
#include <list>

int main() {
    std::list<int> mylist = {1, 2, 3, 4, 5};

    // 删除第一个元素
    mylist.pop_front();

    // 删除最后一个元素
    mylist.pop_back();

    // 删除指定位置的元素
    auto it = std::find(mylist.begin(), mylist.end(), 3);
    if (it != mylist.end()) {
        mylist.erase(it);
    }

    // 遍历list并输出元素
    for (auto num : mylist) {
        std::cout << num << " ";
    }

    return 0;
}

在上面的代码中，我们演示了如何使用pop_front和pop_back分别删除第一个元素和最后一个元素，以及如何使用erase删除指定位置的元素。

其他常用操作

除了插入和删除操作外，std::list还提供了许多其他常用操作，如size()获取元素个数、empty()判断是否为空、clear()清空所有元素等。

通过灵活运用这些操作，可以更好地利用std::list的特性，完成各种需求。

2.1 模拟实现list

在本节中，我们将尝试模拟实现一个简单的双向链表，类似于std::list的基本功能。我们将实现链表节点类和链表类，并添加常见的插入、删除、遍历等操作。

链表节点类的实现

首先，我们定义链表节点类Node，包含数据成员和指向前后节点的指针。

#include <iostream>

template <typename T>
struct Node {
    T data;
    Node* prev;
    Node* next;

    Node(const T& value) : data(value), prev(nullptr), next(nullptr) {}
};

链表类的实现

接下来，我们定义链表类MyList，包含头尾指针和链表大小，并实现插入、删除、遍历等操作。

template <typename T>
class MyList {
private:
    Node<T>* head;
    Node<T>* tail;
    size_t size;

public:
    MyList() : head(nullptr), tail(nullptr), size(0) {}

    void push_back(const T& value) {
        Node<T>* newNode = new Node<T>(value);
        if (head == nullptr) {
            head = tail = newNode;
        } else {
            tail->next = newNode;
            newNode->prev = tail;
            tail = newNode;
        }
        size++;
    }

    void pop_back() {
        if (size == 0) {
            return;
        }
        Node<T>* temp = tail;
        tail = tail->prev;
        delete temp;
        size--;
    }

    void print() {
        Node<T>* current = head;
        while (current != nullptr) {
            std::cout << current->data << " ";
            current = current->next;
        }
        std::cout << std::endl;
    }

    size_t getSize() const {
        return size;
    }

    ~MyList() {
        while (head != nullptr) {
            Node<T>* temp = head;
            head = head->next;
            delete temp;
        }
    }
};

演示代码

int main() {
    MyList<int> myList;

    myList.push_back(1);
    myList.push_back(2);
    myList.push_back(3);
    myList.print(); // 输出: 1 2 3

    myList.pop_back();
    myList.print(); // 输出: 1 2

    std::cout << "Size: " << myList.getSize() << std::endl; // 输出: Size: 2

    return 0;
}

在上面的示例中，我们模拟实现了一个简单的双向链表类MyList，包括了push_back插入元素、pop_back删除尾部元素、print打印链表内容、getSize获取链表大小等操作。

2.2 list的反向迭代器

在本节中，我们将讨论C++标准库中std::list提供的反向迭代器，以及如何使用它来逆向遍历链表中的元素。

反向迭代器的概念

std::list提供了rbegin()和rend()成员函数，分别返回指向最后一个元素和指向第一个元素前一个位置的反向迭代器。通过反向迭代器，我们可以逆向遍历链表，实现从尾部到头部的遍历。

演示代码

下面是一个简单的示例代码，演示如何使用反向迭代器逆向遍历std::list：

#include <iostream>
#include <list>

int main() {
    std::list<int> myList = {1, 2, 3, 4, 5};

    // 使用正向迭代器正向遍历
    std::cout << "正向遍历：" << std::endl;
    for (auto it = myList.begin(); it != myList.end(); ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;

    // 使用反向迭代器逆向遍历
    std::cout << "反向遍历：" << std::endl;
    for (auto rit = myList.rbegin(); rit != myList.rend(); ++rit) {
        std::cout << *rit << " ";
    }
    std::cout << std::endl;

    return 0;
}

在上面的示例中，我们首先创建了一个std::list并初始化了一些整数元素。然后，我们使用正向迭代器和反向迭代器分别进行正向和逆向遍历，并输出遍历结果。

详细解释

  • rbegin()返回指向最后一个元素的反向迭代器，rend()返回指向第一个元素前一个位置的反向迭代器。
  • 逆向遍历时，需要使用rbegin()作为起始迭代器，rend()作为结束迭代器，并通过++rit递增迭代器来遍历元素。

通过反向迭代器，我们可以方便地实现链表的逆向遍历操作，提高了代码的可读性和灵活性。

3. list与vector的对比

在本节中，我们将比较C++标准库中的std::list和std::vector两种容器，分析它们的特点、优缺点以及适用场景。

3.1 list与vector的特点

  • std::list：

    • 底层实现为双向链表，支持高效的插入和删除操作。
    • 不支持随机访问，访问元素的时间复杂度为O(n)。
    • 适用于频繁的插入和删除操作，不需要随机访问元素的场景。

  • std::vector：

    • 底层实现为动态数组，支持随机访问和快速的尾部插入删除操作。
    • 支持通过下标快速访问元素，访问时间复杂度为O(1)。
    • 适用于需要频繁访问元素、尾部插入删除操作和内存连续存储的场景。

3.2 比较示例

下面是一个简单的示例代码，演示了std::list和std::vector的对比：

#include <iostream>
#include <list>
#include <vector>

int main() {
    // 使用std::list
    std::list<int> myList;
    for (int i = 0; i < 5; ++i) {
        myList.push_back(i);
    }

    // 使用std::vector
    std::vector<int> myVector;
    for (int i = 0; i < 5; ++i) {
        myVector.push_back(i);
    }

    // 访问元素比较
    std::cout << "std::list元素访问：" << std::endl;
    for (auto it = myList.begin(); it != myList.end(); ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;

    std::cout << "std::vector元素访问：" << std::endl;
    for (int i = 0; i < myVector.size(); ++i) {
        std::cout << myVector[i] << " ";
    }
    std::cout << std::endl;

    return 0;
}

在上面的示例中，我们分别使用std::list和std::vector存储相同的元素，并比较它们的元素访问方式。

详细解释

  • std::list适用于频繁的插入删除操作，不支持随机访问，访问元素需要通过迭代器。
  • std::vector适用于需要随机访问、尾部插入删除操作的场景，可以通过下标直接访问元素。

根据具体的需求和场景选择合适的容器，可以提高代码的效率和性能。

4. 相关OJ题

在本节中，我们将通过一些相关的OJ题目来帮助大家更好地理解和运用C++中的std::list容器。

OJ题目1：反转链表

问题描述： 给定一个单向链表，将其反转并返回新的头节点。

示例输入：

1 -> 2 -> 3 -> 4 -> 5

示例输出：

5 -> 4 -> 3 -> 2 -> 1

解题思路： 使用std::list可以方便地实现链表的反转操作。

#include <iostream>
#include <list>

struct ListNode {
    int val;
    ListNode* next;
    ListNode(int x) : val(x), next(nullptr) {}
};

ListNode* reverseList(ListNode* head) {
    std::list<int> tempList;
    ListNode* curr = head;
    while (curr) {
        tempList.push_front(curr->val);
        curr = curr->next;
    }

    ListNode* newHead = new ListNode(0);
    ListNode* temp = newHead;
    for (int val : tempList) {
        temp->next = new ListNode(val);
        temp = temp->next;
    }

    return newHead->next;
}

int main() {
    ListNode* head = new ListNode(1);
    head->next = new ListNode(2);
    head->next->next = new ListNode(3);
    head->next->next->next = new ListNode(4);
    head->next->next->next->next = new ListNode(5);

    ListNode* reversedHead = reverseList(head);

    while (reversedHead) {
        std::cout << reversedHead->val << " ";
        reversedHead = reversedHead->next;
    }

    return 0;
}

在上面的示例中，我们通过std::list实现了链表的反转操作，将链表元素存储在std::list中，然后倒序构建新的链表。

OJ题目2：合并两个有序链表

问题描述： 给定两个有序单向链表，将它们合并为一个有序链表并返回。

示例输入：

List1: 1 -> 3 -> 5
List2: 2 -> 4 -> 6

示例输出：

1 -> 2 -> 3 -> 4 -> 5 -> 6

解题思路： 使用std::list的排序功能可以方便地合并两个有序链表。

#include <iostream>
#include <list>

struct ListNode {
    int val;
    ListNode* next;
    ListNode(int x) : val(x), next(nullptr) {}
};

ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
    std::list<int> tempList;
    while (l1) {
        tempList.push_back(l1->val);
        l1 = l1->next;
    }
    while (l2) {
        tempList.push_back(l2->val);
        l2 = l2->next;
    }

    tempList.sort();

    ListNode* newHead = new ListNode(0);
    ListNode* temp = newHead;
    for (int val : tempList) {
        temp->next = new ListNode(val);
        temp = temp->next;
    }

    return newHead->next;
}

int main() {
    ListNode* l1 = new ListNode(1);
    l1->next = new ListNode(3);
    l1->next->next = new ListNode(5);

    ListNode* l2 = new ListNode(2);
    l2->next = new ListNode(4);
    l2->next->next = new ListNode(6);

    ListNode* mergedList = mergeTwoLists(l1, l2);

    while (mergedList) {
        std::cout << mergedList->val << " ";
        mergedList = mergedList->next;
    }

    return 0;
}

在上面的示例中，我们通过std::list的排序功能实现了两个有序链表的合并操作，将两个链表元素存储在std::list中，然后进行排序构建新的有序链表。

好了，感谢大家看到这，如果觉得本篇文章对你有帮助的话，还请点个赞支持一下，有什么问题也可以评论区留言，那么我们下次再见了，Peace~
在这里插入图片描述

阿Chou在努力
关注
C++——std::List
zy2317878的博客
01-25 5519
写在前面 这一篇博客系统学习一下C++中List类的相关函数。之所以要学习这个类，是由于LeetCode中做到了Linked List类，虽然在LeetCode中并没有使用到List类的相关函数，而是主要利用链表的数据结构来完成一些内容，或者说，就是从基础的数据结构来实现接下来要学习的一些链表类的函数，比如：插入，删除结点等等。这篇博客的风格内容与之前博客并无两异，所以主要目的还是对List类的...
c++入门笔记-list链表
weixin_43754049的博客
07-10 932
list基本概念功能：讲数据进行链式存储链表是一种物理存储单元上非连续的存储结构，数据元素的逻辑顺序是通过链表中的指针链接实现链表的组成：由一系列结点组成结点的组成：一个是存储元素的数据域，另一个是存储下一个结点地址的指针域stl中的链表是一个双向循环链表双向：指针域中next指向了下一个结点 而prev指向了前一个结点循环：循环在下面图片中没有展示出来 以下图为例 stl中第一个结点中prev指向的不是null而是最后一个结点 而最后一个结点的next指向的则是第一个结点 形成了循环结构 优点分析：数组输
C++中的std::list迭代器
woods12351的博客
05-12 541
在C++编程中，std::list是一个强大的容器，它基于双向链表实现，提供了高效的插入和删除操作。然而，当我们需要遍历std::list中的元素时，迭代器（Iterator）就成为了我们的得力助手。我们将深入探索C++中std::list的迭代器，并了解它们的工作原理和常见用法。
C++：STD::list的使用
weixin_34372728的博客
05-27 94
2019独角兽企业重金招聘Python工程师标准>>> ...
C++复习（十一）：STL库之list
cly141220010的博客
09-06 1964
之前list这个容器漏写了，后来很长时间没写博客，今天有时间，补一下。 list底层是双向循环链表，因此不支持随机访问，但对于插入和删除能做到O(1)的复杂度，且插入和删除不会使迭代器失效。（PS：vector的插入删除应该会使迭代器失效；deque只有在删除头尾元素时使该元素对应的迭代器失效，其他的插入删除情况会使所有迭代器失效） 1、构造和赋值 #include<iostream> using namespace std; //构造 list<int> L1; .
C++遍历list并删除
gezigezao的博客
05-09 4889
//初始化一个int的list std::list<int> intList; for(int i = 0;i<=3;i++) intList.pushback(i); //使用pushback向List加内容 std::list<int>::iterator itor;//声明一个Int的List的迭代器 for(itor = intList.begin();itor != intList.end();itor++) itor = intList.erase(it
C++std容器list遍历为什么可以用迭代器自加++
卖炫迈的小男孩的博客
08-28 1606
很多初学list会感到疑惑，都说list物理存储上是不具有逻辑性的，即不能通过iter += i；进行对第i个元素的访问。 但是我们能看到以下代码可以运行： 一 #include <iostream> #include <list> using namespace std; int main() { list<int> l1; list<int>...
C++入门---非程序员自学教程.rar
01-06
这篇“C++入门---非程序员自学教程”是专为那些没有编程背景的人设计的，旨在帮助初学者理解C++的基础概念并逐步掌握编程技能。 教程可能包含以下几个部分： 1. **C++简介**：讲解C++的历史、特点和应用领域，以及...
C语言与C++学习-入门与进阶
02-21
7. **STL（Standard Template Library）**：C++标准库中的容器（如vector、list、set等）、算法和迭代器，提供了丰富的数据结构和操作。 学习C语言和C++时，不仅要理解这些概念，还需要通过编写实际的代码来加深...
C++ 入门--非C程序员自学教程
08-19
【C++ 入门--非C程序员自学教程】 C++是一种通用的编程语言，由Bjarne Stroustrup于1983年在C语言的基础上发展而来，它结合了过程化编程、面向对象编程和泛型编程的特点，使得C++在系统编程、应用软件、实时交易、...
std::List类的遍历获得元素的操作二法
10-06
std::list没有[]函数或Get()函数，又不能总是front()的方式排出，如何遍历获得其中的元素呢？比如 遍历显示元素内容为例 ，用两种方式实现。
C++入门大礼包-入门版-FreeVersion
02-17
"C++入门大礼包-入门版-FreeVersion"为初学者提供了一条学习C++的路径。礼包中的组件包括"essential C++ chinese"和"C++ Primer Plus Chinese"两本书，它们都是中文版，帮助中文使用者更好地理解语言概念。 ...
C++ STL容器之list
hestyle的博客
05-02 1190
C++ list 容器 定义于头文件 <list> 申明 template<class T, class Allocator = std::allocator<T> > class list; std::list 是支持常数时间从容器任何位置插入和移除元素的容器。不支持快速随机访问。它通常实现为双向链表。与 std::forward_list 相比，此容器提供...
C++之list成员函数应用总结(二百三十七)
Android系统攻城狮
09-25 1204
本篇目的：理解C++之list成员函数应用。C++中的std::list是一个双向链表的容器，它提供了许多成员函数用于对链表进行操作。以下是一些常用的std::list成员函数的列表：list()：默认构造函数。list(const list& other)：拷贝构造函数。list(size_type count, const T& value)：构造函数，创建包含count个值为value的元素的链表。begin()：返回指向链表第一个元素的迭代器。
【C++】list 迭代器详解和模拟实现
睡不醒的猫的博客
05-04 1544
通过对比我们可以看到，list sort 的效率要远低于 vector sort，甚至可以说，使用list sort 还不如把 list 的数据拷贝到vector中进行排序，然后使用vector sort排序后，再将数据拷贝到 list 中快。这里对 list 和 vector 分别在vs和Linux的编译器下插入相同的元素进行排序对比，通过比较来深刻了解这两种容器在排序性能上的差别，可以帮助我们更直观地感受两种容器的区别，以便更好的使用它们。1. vector排序和 list 排序对比。
[转] C++ STL标准库： std::list使用介绍、用法详解
sroman的博客
03-01 4093
https://blog.csdn.net/u014779536/article/details/111301635
STL STD::list使用说明
热门推荐
lanyzh0909的专栏
05-15 5万+
stl list使用说明 使用标准的std::list进行容器数据处理时，操作比较底层。我们可以，减少引用标准MFC标准库，减少系统的大小，但同时也存在有不方便的操作之处，这里同大家分享一些使用心得......       在使用std::list::iterator链表遍历器进行访问 list     STL 中的list 就是一 双向链表，可高效
c++ STL list遍历器使用方法
FrankDura的博客
01-06 2万+
以int类型的list为例：使用迭代器输出：list<int> con; //声明一个list list<int>::iterator it; //声明一个迭代器 for(it = con.begin();it!=con.end();it++){ cout << *it <<endl; }使用迭代器删除指定值：list<int> con; //声明一个li
Camp4-L0：Linux 前置基础
最新发布
fangsfdavid的博客
10-29 849
书生浦语大模型实战营第四期：Linux前置基础
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值