【C++ STL】list

SuhyOvO

已于 2024-08-04 12:10:03 修改

阅读量957

点赞数 27

分类专栏： C++ 文章标签： c++ list windows

于 2024-08-04 12:07:51 首次发布

本文链接：https://blog.csdn.net/Z1tai/article/details/140904288

版权

C++ 专栏收录该内容

29 篇文章 0 订阅

订阅专栏

文章目录

list

list

与 vector 相比，list 的好处就是每次插⼊或删除⼀个元素就配置或释放⼀个空间，而且原有的迭代器也不会失效。list 是⼀个双向链表，普通指针已经不能满足 list 迭代器的需求，因为 list 的存储空间是不连续的。list 的迭代器必需具备前移和后退功能，所以 list 提供的是 BidirectionalIterator。list 的数据结构中只要⼀个指向 node 节点的指针就可以了。

list (cplusplus.com)

template < 
	class T, //模板参数T
	class Alloc = allocator<T> //空间配置器
         > 
class list; //类模板

关于链表，数据结构处已经讨论过，不再赘述。

1. list的使用

1.1 增删查改

默认成员函数	说明
`list ()`	默认构造
`list (size_type n, const value_type& val = value_type())`	填充构造
`list (InputIter first, InputIter last)`	范围构造
`list (const list& li)`	拷贝构造
`list& operator= (const list& x)`	赋值重载
访问接口	说明
`reference front()`	取头元素
`reference back()`	取尾元素
容量接口	说明
`bool empty() const`	判空
`size_type size() const`	元素个数
`void resize (size_type n, value_type val = value_type())`	修改元素个数
修改接口	说明
`void push_front (const value_type& val)`	头插
`void pop_front()`	头删
`void push_back (const value_type& val)`	尾插
`void pop_back()`	尾删
`iterator insert (iterator position, const value_type& val)`	迭代器插入
`void insert (iterator position, size_type n, const value_type& val)`	迭代器插入
`void insert (iterator position, InputIter first, InputIter last)`	迭代器插入
`iterator erase (iterator position)`	迭代器删除
`iterator erase (iterator first, iterator last)`	迭代器删除
`void assign (InputIter first, InputIter last)`	重置链表
`void assign (size_type n, const value_type& val)`	重置链表
`void clear()`	清空链表

1.2 功能接口

功能接口	说明
`void reverse()`	逆置链表
`void sort(Compare comp = cmp)`	排序链表
`void unique()`	链表去重
`void remove (const value_type& val)`	删除所有指定元素
`void merge (list& x, Compare comp = cmp`	归并两个链表
`void splice (iterator position, list& x)`	接合整个链表
`void splice (iterator position, list& x, iterator i)`	接合单个元素
`void splice (iterator position, list& x, iterator first, iterator last)`	接合一段区间

lt.sort();

list 不支持随机访问，所以不支持算法库中的 sort。

单独内置一个 sort 接口，使用的是归并排序，但效率不高。当需要对数据进行排序的时候，不要选择链表。

lt.sort();
lt.unique();

去重接口可以去掉链表中的重复元素，但前提是需先将链表排成有序状态。

lt.remove(1);

删除链表中所有指定值的元素，不是指定下标位置的元素。

lt.splice(pos, list);              // 转移整个链表
lt.splice(pos, list, i);           // 转移单个节点
lt.splice(pos, list, first, last); // 转移一段区间

接合函数能将一个链表中的一个或多个节点，转移到另一个链表中的指定迭代器位置。可转移整个链表，可转移链表内的一个元素，转移一个迭代器区间。

splice 的功能是转移不是拷贝，原链表中的该节点将不复存在。

list 不支持随机访问，实际中用的不多。list 的重点在于模拟实现。

2. list的模拟实现

2.1 list的定义

// listnode
template<class T>
struct __list_node
{
    __list_node<T>* _prev;
    __list_node<T>* _next;
    T _data;

    __list_node<T>(const T& t = T())
        : _data(t), _prev(nullptr), _next(nullptr)
    {}
};

// list
template <class T>
class list 
{ 
public:
    typedef __list_node<T> Node;
    list() {
        empty_init();
    }
private:
    Node* _head;
}

__list_node 是链表节点类，list 是链表类，他的成员是 __list_node 类型的指针，作链表的带头节点。

一般供他人使用的类，都用 struct 定义，因为 struct 定义的类成员默认都是公有的。

2.2 默认成员函数

/* default constructor */
void empty_init()
{
	_head = new Node(x);
    _head->_prev = _head;
    _head->_next = _head;
}

list()
{
    empty_init();
}

在这里插入图片描述

/* copy constructor */  
//传统写法
list<T>(const list<T>& lt)
{
    empty_init();
    for (auto e : lt)
        push_back(e);
}
//现代写法
list<T>(const list<T>& lt)
{
	empty_init();
	list<T> tmp(lt.begin(), lt.end());
    swap(_head, tmp._head);
}

/* = operator */
//传统写法
list<T>& operator=(const list<T>& lt)
{	
    if (this != &lt) {
        clear();
        for (auto e : lt)
            push_back(e);
    }
    return *this;
}
//现代写法
list<T>& operator=(list<T> lt)
{
    swap(_head, lt._head);
    return *this;
}

/* deconstructor */
void clear()
{
    iterator it = begin();
    while (it != end())
    {
        it = erase(it);
    }
}

~list<T>()
{
    clear();
    delete _head;
}

2.3 迭代器

迭代器模拟指针，意图像指针一样遍历容器。

list 的底层实现并不是 vector 一样的连续空间，而是通过节点地址链接前后，故 list 实现上述操作就需要自行实现一个迭代器类再重载这些运算符。

正向迭代器

template<class T, class Ref, class Ptr>
struct __list_iterator
{
    typedef __list_node<T> list_node;
    typedef __list_iterator<T, Ref, Ptr> self;

    __list_iterator(list_node* n) : _node(n)
    {}

    Ref operator*() {
        return _node->_data;
    }
    Ptr operator->() {
        return &_node->_data;
    }

    self& operator++() {
        _node = _node->_next;
        return *this;
    }
    self& operator--() {
        _node = _node->_prev;
        return *this;
    }

    bool operator!=(const self& s) {
        return _node != s._node;
    }

    list_node* _node;
};

list 容器的迭代器是双向迭代器，不支持随机访问，没有重载+,+=,-,-=。

迭代器的拷贝构造、赋值重载都只需要浅拷贝指针。析构函数无需释放任何资源，节点交由链表进行管理。所以这些编译器默认生成就可以。

解引用箭头

template <class T, class Ref, class Ptr> // 交由list类控制
struct __list_iterator 
{
	typedef __list_iterator<T, Ref, Ptr> iterator;
    Ref operator* () { return  _node->_data; }
    Ptr operator->() { return &_node->_data; }
    //...
};

class list
{
public:
    typedef __list_iterator<T, T&, T*> iterator;                   // 传入普通类型
    typedef __list_iterator<T, const T&, const T*> const_iterator; // 传入常量类型
}

可以给迭代器类增加引用和指针类型的模版参数，分别给*和->重载函数返回值使用。

相当于把具体的元素引用和指针类型交给外界控制。就不需要单独实现一个常量迭代器了。

在这里插入图片描述

当元素是自定义类型时，箭头操作符可以让迭代器直接访问到自定义类型的内部成员。如：

struct AA
{
    AA(int a1 = 0, int a2 = 0) : _a1(a1), _a2(a2) {}
    int _a1;
    int _a2;
};

void test_list()
{
    list<AA> lt;
    lt.push_back(AA(1, 1));
    lt.push_back(AA(2, 2));

    list<AA>::iterator it = lt.begin();
    while (it != lt.end())
    {
        cout << it->_a1 << ":" << it->_a2 << " "; // ->直接访问AA内部成员
        ++it;
    }
    cout << endl;
}

it->AA()->_a1，省略了一个->。

反向迭代器

反向迭代器同样是个适配器，所以它被单独实现在一个文件中。

template <class Iterator, class Ref, class Ptr>
struct reverse_iterator
{
    Iterator _it;
    typedef reverse_iterator self;

    reverse_iterator(Iterator it) // 利用正向迭代器构造出反向迭代器
        :_it(it) 
    {}
    
    self& operator++() // 反向迭代器++，就是正向迭代器--
    {
        --_it;
        return *this;
    }

    self& operator--() // 反向迭代器--，就是正向迭代器++
    {
        ++_it;
        return *this;
    }

    bool operator!=(const self& it) // 反向迭代器是否相等，就是正向迭代器是否相等
    {
        return _it != it._it;
    }
    
    Ref operator*() 
    {
        Iterator tmp = _it;
        return *--tmp;       // 前一个位置的迭代器
    }
    Ptr operator->()
    {
        Iterator tmp = _it;
        return &*--tmp;
    }
};

反向迭代器是对正向迭代器的封装。源码实现使用类型萃取难度较高，我们不使用。

反向迭代器解引用和箭头不是访问当前位置，而是前一个位置。

//list源码
iterator begin() { return (link_type)((*node).next); }
iterator end() { return node; }

reverse_iterator rbegin() { return reverse_iterator(end()); }
reverse_iterator rend() { return reverse_iterator(begin()); }

const_iterator begin() const { return (link_type)((*node).next); }
const_iterator end() const { return node; }

const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }

所有容器的迭代器begin/end()和rbegin/rend()指向的位置正好对应相反。目的是设计出对称形式，因此解引用时返回的是上一个位置的数据。

在这里插入图片描述

反向迭代器遍历：

list<int>::reverse_iterator rit = it.rbegin();
while (rit != it.rend()) {
    // 这里可以访问rit指向的元素，比如输出元素的值
    cout << *rit << " ";
    // 向前移动迭代器
    ++rit;
}

迭代器接口

template<class T>
class list 
{
public:
    typedef __list_iterator<T, T&, T*> iterator;
    typedef __list_iterator<T, const T&, const T*> const_iterator;
    typedef reverse_iterator<iterator, T&, T*> reverse_iterator;
    typedef reverse_iterator<const_iterator, const T&, const T*> const_reverse_iterator;

    iterator begin() { return iterator(_head->_next); }
    iterator end()   { return iterator(_head); }
    
    const_iterator begin() const { return const_iterator(_head->_next); }
    const_iterator end()   const { return const_iterator(_head); }

    reverse_iterator rbegin() { return reverse_iterator(end()); }
    reverse_iterator rend()   { return reverse_iterator(begin()); }

    const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
    const_reverse_iterator rend()   const { return const_reverse_iterator(begin()); }
};

在这里插入图片描述

2.4 基本功能

iterator insert(iterator pos, const T& x)
{
    Node* newNode = new Node(x);
    Node* prev = pos._node->_prev;
    Node* cur = pos._node;
    
    // prev - newNode - cur
    prev->_next = newNode;
    newNode->_prev = prev;
    
    cur ->_prev = newNode;
    newNode->_next =  cur;
    
    return iterator(newNode); //返回迭代器
}
iterator erase(iterator pos)
{
    assert(pos != end());
    
    Node* prev = pos._node->_prev;
    Node* next = pos._node->_next;
    
    delete pos._node;
    
    // prev - pos - after
    prev->_next = next;
    next->_prev = prev;
    
    return iterator(next);
}

list 的插入操作迭代器不会失效，因为迭代器 pos 的值不会改变，始终指向原来的节点。
list 的删除操作迭代器一定失效，因为节点已经被释放了，应修正为 pos 下一个位置。

在这里插入图片描述

void push_back(const T& x) { insert(end(), x); }
void push_front(const T& x) { insert(begin(), x); }

void pop_back() { erase(--end()); }
void pop_front() { erase(begin()); }

3. list对比vector

vector数据结构：
vector 和数组类似，拥有一段连续的内存空间，并且起始地址不变。因此能高效的进行 随机存取，时间复杂度为 O(1)；但因为内存空间是连续的，所以在进行插入和删除操作时，会造成内存块的拷贝，时间复杂度为 O(n)。它与数组最大的区别就是 vector 不需 程序员 自己去考虑 容量问题，库里面本身已经实现了容量的 动态增长，而数组需要 程序员 手动写入扩容函数进形扩容。

list数据结构：
list 是由 双向链表 实现的，因此内存空间是不连续的。只能通过指针访问数据，所以 list 的 随机存取 非常没有效率，时间复杂度为 O(n)；但由于链表的特点，能高效地进行插入和删除。 非连续存储结构：list 是一个 双链表 结构，支持对链表的 双向遍历。每个节点包括三个信息：元素本身，指向 前一个元素 的节点（prev）和指向 下一个元素 的节点（next）。因此 list 可以 高效率 地对 数据元素 任意位置 进行访问和 插入删除 等操作。由于涉及对 额外指针 的维护，所以开销比较大。

区别如下：

vector 的 随机访问 效率高，但在插入和删除时（不包括 尾部）需要 挪动数据，不易操作。
list 的访问要 遍历整个链表，它的 随机访问 效率低。但对数据的插入和删除操作等都比较方便，改变指针的指向即可。
从遍历上来说，list 是单向的，vector 是双向的。
vector 中的 迭代器 在 使用后 就失效了，而 list 的 迭代器 在使用之后还可以 继续使用。

容器	vector	list
底层结构	连续物理空间	空间不连续
随机访问	支持随机访问	不支持随机访问
插入删除	非尾部插入删除要移动数据，效率低 $O (n)$	任意位置的插入删除效率高 $O (1)$
空间利用率	增容代价大，倍数扩容存在一定的空间浪费	按需申请空间，不存在浪费
迭代器	原生指针支持随机访问	迭代器类模拟指针行为，支持双向访问
适用场景	高效存储，随机访问，不关心增删效率	频繁使用插入删除，不关心随机访问

vector与list两种容器各有优劣，实际上vector用的更多些。因为vector支持随机访问，其次空间浪费也不是太严重的问题。

SuhyOvO

关注

27
点赞
踩
12

收藏

觉得还不错? 一键收藏
打赏
0
评论
【C++ STL】list

list是 C++ STL 中的双向链表容器，它能够高效地支持元素的插入和删除操作，即使在容器中间。每个节点存储数据以及指向前一个和后一个节点的指针，这种特性使得 list 在需要频繁插入和删除元素时表现优秀。与 vector 不同，list 的内存空间不是连续的，因此随机访问效率较低（时间复杂度为 O(n)），但它提供了双向遍历的能力。list 还支持逆向迭代器，允许从尾部向头部遍历列表。
复制链接

扫一扫