C++必学系列：STL中的list容器

一、底层：双向链表
二、特性：优势和局限
- 1. 核心优势
- 2. 局限性
三、操作：基础运用
- 1. 初始化与赋值
- 2. 插入与删除
- 3. 遍历与访问
- 4. 其他常用接口
四、适用场景
- 1. 优先使用list的场景
- 2. 优先使用其他容器的场景
五、注意事项
- 1. 迭代器失效
- 2. 排序与算法适配
- 3. 遍历效率优化
六、总结

前言：
在C++ STL的容器家族中，list是一款基于双向链表实现的序列式容器，今天通过本文带大家全面认识STL list，助力在实际开发中精准选型、高效使用。

一、底层：双向链表

STL list的底层是双向循环链表，每个节点（node）包含三个核心部分：

数据域：存储实际的数据元素（T value）；
前驱指针：指向当前节点的前一个节点（prev）；
后继指针：指向当前节点的后一个节点（next）。

与vector的动态数组不同，list的节点在内存中非连续存储，节点间通过指针关联形成链表结构。
这种设计带来了两个关键特性：

插入、删除操作无需移动大量元素，仅需调整指针指向；
无法支持随机访问，访问元素必须从链表头部或尾部开始遍历。

此外，STL list通常会维护一个“哨兵节点”，用于简化链表的空状态处理和首尾操作逻辑。哨兵节点不存储有效数据，其prev指向链表尾节点，next指向链表头节点，使整个链表形成闭环，避免了对空指针的频繁判断。

二、特性：优势和局限

1. 核心优势

高效的插入/删除操作：在链表任意位置插入或删除元素，时间复杂度为O(1)。仅需修改目标节点前后节点的指针，无需移动其他元素，这是list最突出的优势。
稳定的迭代器特性：插入、删除操作不会导致除被删除节点外的其他迭代器失效。因为迭代器本质是指向节点的指针，只要节点未被删除，其地址不变，迭代器就依然有效。
灵活的内存管理：节点按需分配和释放内存，无需预先分配连续空间，适合存储大量动态增减的元素，避免了vector扩容时的内存浪费和拷贝开销。
双向遍历支持：支持从头部（begin()）和尾部（rbegin()）双向遍历，满足复杂场景下的遍历需求。

2. 局限性

不支持随机访问：无法通过下标（[]）或at()方法直接访问指定位置元素，访问第n个元素必须从首尾遍历，时间复杂度为O(n)，效率远低于vector。
额外的空间开销：每个元素除了存储数据，还需额外存储两个指针（prev和next），对于存储小型数据（如int、char）的场景，空间利用率低于连续存储容器。
缓存命中率低：由于节点在内存中分散存储，无法充分利用CPU缓存的局部性原理，遍历效率低于连续内存的容器。

三、操作：基础运用

1. 初始化与赋值

#include<list>#include<iostream>usingnamespacestd;intmain(){// 1. 空构造list<int>lst1;// 2. 构造n个值为val的元素list<int>lst2(5,10);// [10,10,10,10,10]// 3. 迭代器范围构造vector<int>vec={1,2,3,4};list<int>lst3(vec.begin(),vec.end());// [1,2,3,4]// 4. 拷贝构造list<int>lst4(lst3);// [1,2,3,4]// 5. 赋值操作list<int>lst5;lst5=lst4;// [1,2,3,4]return0;}

2. 插入与删除

list提供了丰富的插入和删除接口，覆盖头部、尾部、任意位置的操作：

list<int>lst={1,2,3,4};autoit=lst.begin();advance(it,2);// 移动迭代器到第3个元素（值为3）// 插入操作lst.push_front(0);// 头部插入：[0,1,2,3,4]lst.push_back(5);// 尾部插入：[0,1,2,3,4,5]lst.insert(it,9);// 迭代器位置插入：[0,1,2,9,3,4,5]// 删除操作lst.pop_front();// 头部删除：[1,2,9,3,4,5]lst.pop_back();// 尾部删除：[1,2,9,3,4]lst.erase(it);// 迭代器位置删除（此时it指向3）：[1,2,9,4]// 批量删除lst.remove(2);// 删除所有值为2的元素：[1,9,4]lst.clear();// 清空链表，size变为0

注意：erase(it)会返回指向被删除节点下一个节点的迭代器，避免迭代器失效；而remove(val)会遍历整个链表，删除所有匹配值的节点，时间复杂度为O(n)。

3. 遍历与访问

由于不支持随机访问，list的遍历主要依赖迭代器或范围for循环：

list<int>lst={1,2,3,4,5};// 1. 正向迭代器遍历for(autoit=lst.begin();it!=lst.end();++it){cout<<*it<<" ";// 输出：1 2 3 4 5}// 2. 反向迭代器遍历for(autoit=lst.rbegin();it!=lst.rend();++it){cout<<*it<<" ";// 输出：5 4 3 2 1}// 3. 范围for循环（C++11及以上）for(intval:lst){cout<<val<<" ";// 输出：1 2 3 4 5}// 4. 访问首尾元素（无at()和[]方法）cout<<lst.front();// 1cout<<lst.back();// 5

4. 其他常用接口

size()：返回当前元素个数；
empty()：判断链表是否为空；
reverse()：反转链表，时间复杂度O(n)；
sort()：链表内部排序（非标准库通用sort，因通用sort需随机访问迭代器），时间复杂度O(n log n)；
unique()：删除连续重复的元素（需先排序），时间复杂度O(n)；
splice()：合并两个链表，无需拷贝元素，仅调整指针，时间复杂度O(1)（按位置合并）或O(n)（按范围合并）。

list<int>lst1={3,1,4,2};list<int>lst2={5,6};lst1.sort();// 排序：[1,2,3,4]lst1.unique();// 无连续重复，保持不变lst1.reverse();// 反转：[4,3,2,1]// 把lst2的所有元素插入到lst1头部lst1.splice(lst1.begin(),lst2);// lst1: [5,6,4,3,2,1], lst2: 空

四、适用场景

list的特性决定了它并非“万能容器”，需根据实际场景选型：

1. 优先使用list的场景

频繁在任意位置插入、删除元素（尤其是中间位置），且元素个数动态变化较大；
需要保证迭代器稳定性，插入/删除后无需重新获取迭代器；
无需随机访问元素，仅需双向遍历；
需要高效合并两个链表（splice接口优势）。

2. 优先使用其他容器的场景

需要随机访问元素（如下标访问）：优先选择vector、array；
元素个数固定或变化不大，且以遍历、读取为主：优先选择vector。
需要在尾部高效插入/删除，且支持随机访问：vector（尾部操作O(1)）；
存储小型数据（如int），追求空间利用率：vector（无指针额外开销）。

五、注意事项

1. 迭代器失效

list的迭代器仅在对应节点被删除时失效，其他情况（插入、移动）均有效。因此在遍历删除时，需注意保存下一个迭代器：

// 错误写法：erase后it失效，++it会出错for(autoit=lst.begin();it!=lst.end();++it){if(*it%2==0){lst.erase(it);// it失效}}// 正确写法：利用erase返回的迭代器for(autoit=lst.begin();it!=lst.end();){if(*it%2==0){it=lst.erase(it);// 接收下一个有效迭代器}else{++it;}}