C++：list函数介绍

list

• [1. list的介绍](#1. list的介绍)
• [2. list的使用](#2. list的使用)
• • [2.1 构造](#2.1 构造)
  • [2.2 iterator的使用](#2.2 iterator的使用)
  • [2.3 常用函数](#2.3 常用函数)
• 3.list和vector的对比

1. list的介绍

list 是标准模板库提供的一种双向链表 容器，每个元素包含指向前后节点的指针，支持双向遍历

元素在内存中不必连续，插入/删除不引起其他元素移动

在已知位置进行插入或删除操作的时间复杂度为O(1)，相较于vector的O(N)，效率更高

无法用 或+n直接跳转，访问第n个元素需要遍历，复杂度为O(n)

2. list的使用

//下面这段代码是list的常用操作
#include <list>

std::list<int> lst = {1, 2, 3}; //构造
lst.push_back(4);      // 尾部插入 O(1)
lst.push_front(0);     // 头部插入 O(1)
auto it = lst.begin();
++it;                  // 移动到第二个元素
lst.insert(it, 99);    // 在迭代器位置前插入 O(1)
lst.erase(it);         // 删除该位置元素 O(1)
lst.pop_front();       // 删除头部
lst.pop_back();        // 删除尾部

2.1 构造

默认构造：构造一个空的list，没有任何元素

list()
std::list<int> lst1;          // 空列表
std::list<std::string> lst2;  // 空列表

填充构造：构造一个包含n个元素的list，每个元素都是val

size_type ：无符号整数类型，通常是size_t

val：默认值参数，如果不提供第二个参数，则使用值初始化

list(size_type n, const value_type& val = value_type())
std::list<int> lst3(5, 10);      // 5 个元素，每个都是 10 → [10,10,10,10,10]
std::list<std::string> lst4(3);  // 3 个空字符串 → ["","",""]

区间构造：用迭代器区间[first,last)中的元素构造list

first，last 可以是任意输入迭代器，区间是左闭右开，包含first指向的元素，不包含last指向的元素

list(InputIterator first, InputIterator last)
int arr[] = {1,2,3,4,5};
std::list<int> lst5(arr, arr+3);      // 取数组前3个 → [1,2,3]
std::vector<int> v = {10,20,30};
std::list<int> lst6(v.begin(), v.end()); // 从 vector 拷贝 → [10,20,30]

拷贝构造：构造一个新list，深拷贝已有list x的全部元素，新容器和原容器独立，修改一个不影响另一个

list(const list& x)
std::list<int> original = {1,2,3};
std::list<int> copy(original);   // copy 也是 [1,2,3]

2.2 iterator的使用

begin() 返回指向第一个元素的迭代器

end() 返回指向最后一个元素之后的位置的迭代器，这个位置不包含有效元素

配合使用可以遍历整个列表：[first，end)左闭右开区间

如果列表为空，则begin() == end()

std::list<int> lst = {10, 20, 30};
for (auto it = lst.begin(); it != lst.end(); ++it) {
    std::cout << *it << " ";  // 输出：10 20 30
}

rbegin() 返回指向最后一个元素的反向迭代器

rend() 返回指向第一个元素之前的位置的反向迭代器

std::list<int> lst = {10, 20, 30};
for (auto it = lst.rbegin(); it != lst.rend(); ++it) {
    std::cout << *it << " ";  // 输出：30 20 10
}

2.3 常用函数

• list不支持 或at()随机访问因为list是链表

empty() 检测list是否为空

空返回true，否则返回false

std::list<int> lst;
if (lst.empty()) {
    std::cout << "列表为空" << std::endl;
}
lst.push_back(10);
std::cout << std::boolalpha << lst.empty(); // 输出 false

size() 返回list中当前有效元素个数

std::list<int> lst = {1, 2, 3};
std::cout << lst.size(); // 输出 3
lst.clear();
std::cout << lst.size(); // 输出 0

front() 返回第一个元素的引用

前提是list不能为空，否则行为未定义，使用前建议先用empty()检查

std::list<int> lst = {10, 20, 30};
lst.front() = 100;      // 修改第一个元素
std::cout << lst.front(); // 输出 100

back() 返回最后一个元素的引用

前提是list不能为空

std::list<int> lst = {10, 20, 30};
lst.back() = 300;
std::cout << lst.back(); // 输出 300

push_front(val) 在链表头部插入值为val的新元素

pop_front() 删除链表头部第一个元素（链表必须为非空）

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

int main() {
    list<int> lst = {2, 3, 4};
    
    lst.push_front(1);   // 现在: 1, 2, 3, 4
    lst.pop_front();     // 删除头部，现在: 2, 3, 4
    
    for (int x : lst) cout << x << " "; // 输出: 2 3 4
    return 0;
}

push_back(val) 在链表尾部插入值为 val 的新元素

pop_back() 删除链表尾部最后一个元素（链表必须非空）

list<int> lst = {1, 2, 3};
lst.push_back(4);    // 现在: 1, 2, 3, 4
lst.pop_back();      // 删除尾部，现在: 1, 2, 3

insert(position, val) 在迭代器position 所指向的位置之前插入值为val的元素，返回指向新插入元素的迭代器，也可以插入多个相同值或一个范围（重载版本）

list<int> lst = {10, 20, 30};
auto it = lst.begin(); // 指向 10
++it;                  // 现在指向 20

lst.insert(it, 15);    // 在 20 之前插入 15 → 10, 15, 20, 30

// 插入多个
lst.insert(lst.end(), 2, 99); // 尾部插入两个 99 → ... 30, 99, 99

erase(position) 删除迭代器 position 指向的元素，返回指向被删除元素之后元素的迭代器

也可以删除一个范围erase(first, last)

list<int> lst = {5, 10, 15, 20};
auto it = lst.begin(); // 指向 5
++it;                  // 指向 10
it = lst.erase(it);    // 删除 10，现在 lst = {5, 15, 20}，it 指向 15

swap(other) 交换两个 list 的全部内容，时间复杂度O(1)，只交换内部指针

list<int> a = {1, 2, 3};
list<int> b = {4, 5};
a.swap(b);   // a = {4,5}, b = {1,2,3}
// 也可以用 std::swap(a, b);

clear() 删除链表中的所有元素，使容器变为空(size = 0)

list<int> lst = {1, 2, 3, 4};
lst.clear();   // 现在 lst.empty() == true

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

void print(const list<int>& l) {
    for (int x : l) cout << x << " ";
    cout << endl;
}

int main() {
    list<int> mylist;

    // 尾部插入
    mylist.push_back(10);
    mylist.push_back(20);
    mylist.push_back(30);
    cout << "After push_back: "; print(mylist); // 10 20 30

    // 头部插入
    mylist.push_front(5);
    cout << "After push_front: "; print(mylist); // 5 10 20 30

    // 在中间插入（在 20 之前插入 15）
    auto it = mylist.begin();
    ++it; ++it; // 现在 it 指向 20
    mylist.insert(it, 15);
    cout << "After insert: "; print(mylist); // 5 10 15 20 30

    // 删除头部和尾部
    mylist.pop_front();
    mylist.pop_back();
    cout << "After pop_front & pop_back: "; print(mylist); // 10 15 20

    // 删除中间元素（删除 15）
    it = mylist.begin();
    ++it; // 指向 15
    mylist.erase(it);
    cout << "After erase: "; print(mylist); // 10 20

    // swap
    list<int> another = {100, 200};
    mylist.swap(another);
    cout << "After swap, mylist: "; print(mylist); // 100 200
    cout << "After swap, another: "; print(another); // 10 20

    // clear
    mylist.clear();
    cout << "After clear, size = " << mylist.size() << endl; // 0

    return 0;
}

3.list和vector的对比

	vector	list
底层结构	动态顺序表，一段连续的空间	带头结点的双向循环链表
随机访问	支持随机访问，访问某个元素效率O(1)	不支持随机访问，访问某个元素效率O(N)
插入和删除	任意位置插入和删除效率低，需要搬移元素，时间复杂度为O(N)，插入时有可能需要增容，增容：需要开辟新空间，拷贝元素，释放旧空间，导致效率更低	任意位置插入和删除效率高，不需要搬移元素，时间复杂度为O(1)
空间利用率	底层为连续空间，不容易造成内存碎片，空间利用率高，缓存利用率高	底层节点动态开辟，小节点容易造成内存碎片，空间利用率低，缓存利用率低
迭代器	原生态指针	对原生态指针(节点指针)进行封装
迭代器失效	在插入元素时，要给所有的迭代器重新赋值，因为插入元素有可能会导致重新扩容，致使原来迭代器失效，删除时，当前迭代器需要重新赋值，否则会失效	插入元素不会导致迭代器失效，删除元素时，只会导致当前迭代器失效，其他迭代器不受影响
使用场景	需要高效存储，支持随机访问，不关心插入删除效率	大量插入和删除操作，不关心随机访问