【C++】list的介绍及使用 | 模拟实现list | 对比vector和list

原创

已于 2023-11-06 16:18:26 修改 · 1.1k 阅读

标签

#c++ #list #开发语言

于 2023-10-26 12:04:58 首次发布

一、list的介绍及使用

什么是list？

1.list是可以在常数范围内在任意位置进行插入和删除的序列式容器，并且该容器可以前后双向迭代。

2.其底层是双向链表结构。

双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向其前一个元素和后一个元素。

3.list与forward_list非常相似。

最主要的不同在于forward_list是单链表，只能朝前迭代。（这也使得它更加得简单高效）

4.与其他的序列式容器相比(array，vector，deque)，list通常在任意位置进行插入、移除元素的执行效率更好。

5.与其他序列式容器相比，list和forward_list最大的缺陷是不支持任意位置的随机访问。

比如：要访问list的第6个元素，必须从已知的位置（如头部或尾部）迭代到该位置，在这段位置上迭代需要线性的时间开销。

list还需要一些额外的空间，以保存每个节点的相关联信息。（对于存储类型较小元素的大list来说，这可能是一个重要的因素）

list的基本操作

包头文件：<list>

就和我们用过的vector一样，list也是个类模板：

#include<iostream>
#include<list>
using namespace std;

int main() {
    list<int> lt;
    return 0;
}

list的大部分操作，我们不需要记忆，因为很多用起来和vector、string的差不多，就算忘了，直接查文档即可。所以这里就一笔带过。

增删查改

函数名	功能
assign	覆盖
push_front	头插
pop_front	头删
push_back	尾插
pop_back	尾删
insert	插入
erase	删除
swap	交换
resize	改变大小
clear	清空

注：

1.因为list不是连续的结构，它是指针串起来的链表，所以不支持随机访问，“方括号+下标”的访问方式不能用了！

2.我们要遍历list的话就用范围for 或者迭代器。

3.和vector一样，list里没有专门再实现find，要想查找就用<algorithm>下的find。

在调用find时，用第二种方式：

因为find是函数模板，不是vector里的。

在学vector时，我们在insert和erase处，讲到了迭代器失效的问题。这个问题是否同样存在于list中呢？

实际上，list中进行insert操作是不存在迭代器失效的问题的，而erase操作则会有。

因为insert仅需要改变指针间的指向关系即可，不存在变成野指针的问题：

而erase会导致指向被删节点的指针变成野指针的问题，所以存在迭代器失效的情况。

获取list元素

函数名	功能
front	返回list的第一个节点中值的引用
back	返回list的最后一个节点中值的引用

不常见操作的使用说明

这些操作很少用，但由于很多我们之前没见过，所以这里也做下说明。

接合splice

splice意为“接合”，即把一个链表接合到另一个链表上去。

示例：

int main() {
    list<int> l1(4,0);
    for (auto e : l1) {
        cout << e << " ";
    }
    cout << endl;

    list<int> l2(2, 1);
    for (auto e : l2) {
        cout << e << " ";
    }
    cout << endl;

    l1.splice(l1.begin(), l2);
    for (auto e : l1) {
        cout << e << " ";
    }
    cout << endl;
    return 0;
}

移除remove

remove可以移除所有的待找元素。

示例：

int main() {
    list<int> lt;
    lt.push_back(1);
    lt.push_back(1);
    lt.push_back(1);
    lt.push_back(2);
    lt.push_back(3);
    lt.push_back(4);
    lt.remove(1);
    for (auto e : lt) {
        cout << e << " ";
    }
    return 0;
}

相关函数remove_if()用于删除满足特定条件的元素。

去重unique

unique仅对有序的元素集合有效，所以，在使用unique前要先对集合排序！

示例：

int main() {
    list<int> lt;
    lt.push_back(4);
    lt.push_back(1);
    lt.push_back(9);
    lt.push_back(2);
    lt.push_back(2);
    lt.push_back(4);
    lt.sort();
    lt.unique();
    for (auto e : lt) {
        cout << e << " ";
    }
    cout << endl;
    return 0;
}

其余还有：合并merge、排序sort、逆置reverse，就不详讲了，最重要的是要培养阅读文档的能力。

二、模拟实现list

从0开始实现一遍list，可以让我们清晰地认识list的结构。

大框架

先把大框架搭出来，再慢慢填充血肉。

list是链表结构，本身要定义出一个类去描述它；而list的每个节点list_node，也需要定义一个类来描述。

namespace jzy 
{
    template<class T>
    class list_node
    {
    public:
        list_node<T>* _pre;   
        list_node<T>* _next;
        T _data;
    };

    template<class T>
    class list
    {
        typedef list_node<T> Node;    //list_node太长了，改成Node用着顺手
    public:

    private:
        Node* _head;    //list是带头结点的链表，所以成员变量只需一个头节点
    };
}

注：要把list_node的类设成public，这样类外才能访问到。如果不写public的话，默认权限是private。

或者设计成struct{};，struct的默认访问权限是public。

构造函数

先实现节点的构造函数：

我们想要达到的效果是：构造出的list，内含一个头点node，这个node已被初始化过。

如图：list为双向循环链表，其node被初始化：

既然想要node在创建伊始就被初始化，那我们可以直接写个node的构造函数：

class list_node
    {
    public:
        T _data;
        list_node<T>* _pre;
        list_node<T>* _next;

        list_node(const T& x = T())
            :_data(x)
            ,_pre(nullptr)
            ,_next(nullptr)
        {}
    };

这样，我们每创建出一个node，就是被初始化过的了。

class list_node
{
public:
    T _data;
    list_node<T>* _pre;
    list_node<T>* _next;

    list_node(const T& x = T())
        :_data(x)
        ,_pre(nullptr)
        ,_next(nullptr)
    {}
};

再实现list的构造函数：

因为是带头双向循环列表，所以创建伊始，就有个哨兵位的头节点。

namespace jzy
{
    template<class T>
    class list_node
    {
    public:
        T _data;
        list_n

最低0.47元/天解锁文章