C++ list：链表的“乐高积木”与“灵活小火车”

C++ list：链表的“乐高积木”与“灵活小火车”

开篇小故事：魔术师的“无限链条”

想象一位魔术师有一条神奇的链条：

• 他可以瞬间在任意位置插入或取下链环，无需打断整条链条。
• 每个链环都自带“记忆”，能记住前后邻居的位置。
• 链条可以无限延长或缩短，且永远保持连贯。

这就是C++标准库中的**list**——它用双向链表的结构，赋予你高效增删元素的能力，告别数组搬移数据的笨重操作！

一、list是什么？

std::list是C++标准模板库（STL）提供的双向链表容器。

• 节点结构：每个元素（节点）包含数据和两个指针（指向前后节点）。
• 高效增删：在任意位置插入/删除元素的时间复杂度为O(1)。
• 不支持随机访问：不能通过下标直接访问元素（需从头遍历）。

与vector对比

二、list的“基本操作”

1. 创建list

#include <list>
using namespace std;

list<int> nums1;                // 空链表
list<string> names(3, "Alice"); // 3个"Alice"
list<char> letters{'a', 'b', 'c'}; // 初始化列表（C++11）
list<double> values2(values1);  // 拷贝构造

2. 添加元素

nums1.push_back(10);    // 末尾插入
nums1.push_front(0);    // 头部插入
auto it = nums1.begin();
advance(it, 2);         // 移动迭代器到第3个位置
nums1.insert(it, 99);   // 在指定位置插入
nums1.emplace_back(20); // C++11，避免临时对象拷贝

3. 删除元素

nums1.pop_back();       // 删除末尾元素
nums1.pop_front();      // 删除头部元素
nums1.erase(it);        // 删除迭代器指向的元素
nums1.remove(99);       // 删除所有值为99的元素
nums1.clear();          // 清空链表

4. 访问元素

cout << nums1.front();  // 第一个元素
cout << nums1.back();   // 最后一个元素
// 注意：list没有[]和at()方法！

三、list的“核心魔法”：迭代器遍历

1. 遍历链表

// 传统迭代器
for (auto it = letters.begin(); it != letters.end(); ++it) {
    cout << *it << " ";
}

// 范围for循环（C++11）
for (char c : letters) {
    cout << c << " ";
}

// 反向遍历
for (auto rit = letters.rbegin(); rit != letters.rend(); ++rit) {
    cout << *rit << " ";
}

2. 查找元素

auto it = find(letters.begin(), letters.end(), 'b');
if (it != letters.end()) {
    cout << "找到b，位置：" << distance(letters.begin(), it);
}

3. 拼接链表

list<int> list1{1, 2, 3};
list<int> list2{4, 5, 6};
list1.splice(list1.end(), list2); // 将list2全部元素移动到list1末尾
// list1变为{1,2,3,4,5,6}，list2为空

四、list的“独门绝技”

1. 排序与去重

list<int> nums{3, 1, 4, 1, 5};
nums.sort();            // 升序排序：{1, 1, 3, 4, 5}
nums.unique();          // 去重：{1, 3, 4, 5}
nums.reverse();         // 反转：{5, 4, 3, 1}

2. 合并有序链表

list<int> listA{1, 3, 5};
list<int> listB{2, 4, 6};
listA.merge(listB);     // listA变为{1,2,3,4,5,6}，listB为空
// 注意：合并前两个链表必须已排序！

3. 自定义排序规则

// 按降序排序
nums.sort([](int a, int b) { return a > b; });

五、list的“使用场景”

1. 高频增删中间元素

• 场景：实时游戏中的角色行为队列，频繁插入/删除事件。
• 优势：避免vector搬移数据的性能损耗。

2. 大型对象存储

• 场景：存储文件块（每个块是独立对象）。
• 优势：插入删除时无需拷贝大量数据。

3. 需要稳定迭代器

• 场景：遍历过程中可能插入删除元素。
• 优势：list增删元素不会使其他迭代器失效（除非指向被删除元素）。

六、list的“注意事项”

1. 迭代器失效陷阱

• 插入操作：不会使任何迭代器失效。
• 删除操作：仅使被删除元素的迭代器失效。

auto it = nums.begin();
++it;
nums.erase(it);      // 此时it已失效，不可再使用

2. 性能陷阱：线性访问

// 低效操作：频繁访问中间元素
for (int i = 0; i < nums.size(); i++) {
    // 需要从头遍历到第i个位置！
    auto it = nums.begin();
    advance(it, i);
    cout << *it;
}

3. 内存开销

每个元素需要额外存储前后指针（每个指针通常4/8字节），小对象存储效率低于vector。

七、动手实验

1. 实现LRU缓存

利用list快速移动元素的特性：

list<pair<int, string>> cache;
unordered_map<int, list<pair<int, string>>::iterator> map;

void access(int key) {
    auto it = map[key];
    cache.splice(cache.begin(), cache, it); // 移动到头部
}

2. 合并两个有序链表

list<int> listX{1, 3, 5};
list<int> listY{2, 4, 6};
listX.merge(listY); 
// listX变为{1,2,3,4,5,6}

总结：list——链表的“灵活艺术”

std::list以其高效的增删能力和稳定的迭代器，成为处理动态序列的利器。

• 像拼乐高一样操作数据：在任意位置轻松插入或移除“积木块”。
• 像火车调度员一样管理内存：每节“车厢”（节点）独立存在，通过指针链接。

当你需要频繁修改数据序列时，不妨让list成为你的首选容器——它不仅是链表，更是高效数据操作的秘密武器！

（完）

希望这篇博客能帮助读者掌握C++ list的核心技巧！如果需要调整示例或补充细节，请随时告诉我~ 😊