List基本使用（C++）

目录

1.list的介绍

2.list的使用

list的构造

[list的size() 和 max_size()](#list的size() 和 max_size())

list遍历操作

list元素修改操作

assign()函数

[push_front(),push_back 头插，尾插](#push_front(),push_back 头插，尾插)

[pop_front() pop_back 头删尾删](#pop_front() pop_back 头删尾删)

insert()函数

swap()函数

resize()函数

clear()函数

list类数据操作

splice()函数

sort()函数

unique()函数

reverse()函数（逆置链表）

---

1.list的介绍

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

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

3.list与forward_list非常相似：最主要的不同在于forward_list是单链表，只能朝前迭代，已让其更简单高效。

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

5.与其他序列式容器相比，list和forward_list最大的缺陷是不支持任意位置的随机访问，比如：要访问list的第六个元素，必须从已知的位置（比如头部或者尾部）迭代到该位置，在这段位置上迭代需要线性的时间开销；list还需要一些额外的空间，以保存每个节点的相关联信息（对于存储类型较小元素的大list来说这可能是一个重要的因素）

2.list的使用

list类为类模板，所以在使用时需要带上类型表示一个具体的类，例如数据类型为int类型的list使用时需要写为list<int>

list的构造

#include <iostream>
using namespace std;
#include <list>
#include <vector>
int main() {
    //1.无参构造
    list<int> ls1;
        //list没有capacity
    cout << ls1.size() << endl;//0
    
    //2.指定个数类型值进行构造
    list<int> ls2(4,5);
    cout << ls2.size() <<endl;//4
    for(auto e : ls2){
        cout << e << " ";
    }
    cout << endl;//5 5 5 5
    
    //3.使用类对象迭代器区间进行构造
    
    list<int> ls3(ls2.begin(),ls2.end());
    cout << ls3.size() <<endl;//4
    for(auto e : ls3){
        cout << e << " ";
    }
    cout << endl;//5 5 5 5
    
    //也可以使用其然类对象迭代器区间进行构造
    vector<int> v(4,5);
    list<int> ls4(v.begin(),v.end());
    cout << ls4.size() <<endl;//4
    for(auto e : ls4){
        cout << e << " ";
    }
    cout << endl;//5 5 5 5

    //4.拷贝构造
    list<int> ls5(ls1);
    //list<int> ls5 = ls1;
    cout << ls5.size() << endl;//0
    return 0;
}

list的size() 和 max_size()

list遍历操作

在list中，只有迭代器遍历方式

list元素修改操作

assign()函数

使用assign()函数可以为调用对象链表重新分配内容，如果原始链表中有数据，那么将覆盖原始内容

int main(){
    list<int> ls1(4,8);
    list<int> ls2 = {1,2,3,4,5};
    
    for(auto e : ls1)
        cout << e << " ";
    cout << endl;//8 8 8 8
    
    ls1.assign(ls2.begin(),ls2.end());
    for(auto e : ls1)
        cout << e << " ";
    cout << endl;//1 2 3 4 5
    
    return 0;
}

push_front(),push_back 头插，尾插

int main(){
    list<int> ls1 = {1,2,3,4,5};
    
    ls1.push_front(0);
    for(auto e : ls1)
        cout << e << " ";
    cout << endl;//0 1 2 3 4 5
    
    ls1.push_back(6);
    ls1.push_back(7);
    for(auto e : ls1)
    cout << e << " ";
    cout << endl;//0 1 2 3 4 5 6 7
    
    return 0;
}

pop_front() pop_back 头删尾删

int main(){
    list<int> ls1 = {1,2,3,4,5};
    
    ls1.pop_front();
    ls1.pop_front();
    for(auto e : ls1)
        cout << e << " ";
    cout << endl;//3 4 5
    
    ls1.pop_back();
    ls1.pop_back();
    for(auto e : ls1)
        cout << e << " ";
    cout << endl;//3 
    return 0;
}

**insert()**函数

对于insert()函数来说，基本不存在迭代器失效问题，因为list不存在扩容问题并且空间基本不是连续的，所以pos位置在插入数据后可能并没有改变

int main(){
    list<int> ls1 = {1,2,3,4,5};
    
    ls1.insert(ls1.end(), 6);
    ls1.insert(ls1.begin(), 2, 0);
    for(auto e : ls1)
        cout << e << " ";
    cout << endl;//0 0 1 2 3 4 5 6
    
    list<int> ls2 = {1,3,1,4};
    ls1.insert(ls1.begin(), ls2.begin(), ls2.end());
    for(auto e : ls1)
        cout << e << " ";
    cout << endl;//1 3 1 4 0 0 1 2 3 4 5 6 
    
    return 0;
}

int main(){
    list<int> ls1 = {1,2,3,4,5};
    list<int>::iterator it =  find(ls1.begin(), ls1.end(), 2);
        it = ls1.erase(it);
        for (auto e : ls1)
        {
            cout << e << " ";
        }
    //1 3 4 5
     
        cout << endl << *it << endl;
    //3
    return 0;
}

swap()函数

交换两个链表

int main(){
    list<int> ls1 = {1,2,3,4,5};
    cout << "ls1: ";
    for(auto e : ls1)
    cout << e << " ";
    cout << endl;
    
    list<int> ls2 = {5,4,3,2,1};
    cout << "ls2: ";
    for(auto e : ls2)
    cout << e << " ";
    cout << endl;
    
    swap(ls1, ls2);
    cout << "ls1: ";
    for(auto e : ls1)
    cout << e << " ";
    cout << endl;
    
    cout << "ls2: ";
    for(auto e : ls2)
    cout << e << " ";
    cout << endl;
    return 0;
}

**resize()**函数

修改指定对象链表中的有效数据节点的个数

当n小于当前链表的size，则实现删除效果，否则初始化为指定类型的数据（默认为对应类型的默认值）

int main(){
    list<int> ls1 = {1,2,3,4,5};
    cout << "ls1 size:" << ls1.size() << endl;
    
    //设定大小大于原来size，默认补充
    ls1.resize(10);
    cout << "ls1 size:" << ls1.size() << endl;
    for(auto e : ls1)
    cout << e << " ";
    cout << endl;
    
    
    //设定大小小于原来size，相当于删除
    ls1.resize(2);
    cout << "ls1 size:" << ls1.size() << endl;
    for(auto e : ls1)
    cout << e << " ";
    cout << endl;
    return 0;
}
输出结果：
ls1 size:5
ls1 size:10
1 2 3 4 5 0 0 0 0 0 
ls1 size:2
1 2

**clear()**函数

使用clear()函数可以清空调用对象链表当前所有的有效数据节点**(不会删除头节点)**

int main(){
    list<int> ls1 = {1,2,3,4,5};
    cout << "清空前：" << endl;
    for(auto e : ls1)
    cout << e << " ";
    cout << endl;
    
    ls1.clear();
    cout << "清空后：" << endl;
    for(auto e : ls1)
    cout << e << " ";
    cout << endl;
    return 0;
}

清空前：
1 2 3 4 5 
清空后：

list类数据操作

**splice()**函数

使用splice()函数可以将指定对象中的内容拼接到调用对象的链表中的指定位置后(拼结后原链表不存在，只剩拼接后的新链表)

int main(){
    list<int> ls1 = {1,3,1,4};
    list<int> ls2 = {5,2,0};
    
    ls1.splice(ls1.begin(), ls2);
    for(auto e : ls1)
    cout << e << " ";
    cout << endl;//5 2 0 1 3 1 4
    
    for(auto e : ls2)
    cout << e << " ";
    cout << endl;//ls2 内容为空
    
    return 0;
}

注意，splice()函数中的迭代器为双向迭代器(bidirectional iterator)，传递的迭代器也必须为双向迭代器或者单向迭代器(forward iterator)，不可以随机迭代器(random iterator)

随机访问迭代器是特殊的双向迭代器，双向迭代器和随机访问迭代器是特殊的单向迭代器

随机访问迭代器支持以下操作：

双向迭代器支持以下操作：

单向迭代器支持以下操作：

#include <iostream>
#include <list>
#include <vector>
using namespace std;
 
int main()
{
    list<int> ls{ 1,2,3,4,5 };
    vector<int> v1(3, 6);
 
    cout << "拼接前：" << endl;
    for (auto num : ls)
    {
        cout << num << " ";
    }
 
    cout << endl;
 
    for (auto num : v1)
    {
        cout << num << " ";
    }
 
    cout << endl;
    list<int>::iterator it = find(ls.begin(), ls.end(), 2);
    ls.splice(it, v1);
    cout << "拼接后：" << endl;
    for (auto num : ls)
    {
        cout << num << " ";
    }
 
    cout << endl;
 
    for (auto num : v1)
    {
        cout << num << " ";
    }
 
    cout << endl;
    return 0;
}
报错信息：
"std::list<int,std::allocator<int>>::splice": 没有重载函数可以转换所有参数类型

因为vector的迭代器为随机访问迭代器，所以当传入双向迭代器时会报错

**sort()**函数

使用sort()函数可以为调用对象的链表进行排序，底层是归并排序

默认是升序排序，可以通过仿函数改变为降序（后续介绍仿函数）

int main()
{
    //升序
    list<int> ls = {9,0,3,2,21,43,11,0};
    for (auto num : ls)
    {
        cout << num << " ";
    }
    cout << endl;
    ls.sort();
    for (auto num : ls)
    {
        cout << num << " ";
    }
    cout << endl;
    //降序
    ls.sort(greater<int>());
    for (auto num : ls)
    {
        cout << num << " ";
    }
    return 0;
}
9 0 3 2 21 43 11 0 
0 0 2 3 9 11 21 43 
43 21 11 9 3 2 0 0

当list排序数据非常多的时候，可以考略将list数据拷贝到vector中排序，排序后再拷回list中。这段过程看似麻烦，但总体消耗时间比单独使用list中sort()函数小

int main()
{
    srand(time(NULL));
    const int N = 10000;//一万个数据
 
    list<int> ls;
    list<int> ls1;
 
    //向两个链表中插入数据
    for (int i = 0; i < N; ++i)
    {
        auto e = rand();
        ls.push_back(e);
        ls1.push_back(e);
    }
 
    //直接使用sort()排序
    size_t begin = clock();
    ls.sort();
    size_t end = clock();
 
    //拷贝到vector类中排序
    size_t begin1 = clock();
    vector<int> v(ls1.begin(), ls1.end());
    sort(v.begin(), v.end());
    ls1.assign(v.begin(), v.end());
    size_t end1 = clock();
 
    cout << "直接排序：" << end - begin << "ms" << endl;
    cout << "拷贝后排序再拷贝：" << end1 - begin1 << "ms" << endl;
 
    return 0;
}
输出结果：
直接排序：2934ms
拷贝后排序再拷贝：586ms

**unique()**函数

unique()函数可以为链表去除重复数据的有效数据节点，但是使用unique()函数之前必须确保链表有序

int main(){
    list<int> ls = {9,0,3,2,2,21,43,11,0};
    //进行升序
    ls.sort();
    for (auto e : ls)
    cout << e << " ";
    cout << endl;
    
    ls.unique();
    for (auto e : ls)
    cout << e << " ";
    cout << endl;
    return 0;
}
输出结果；
0 0 2 2 3 9 11 21 43 
0 2 3 9 11 21 43 

**reverse()**函数（逆置链表）

int main(){
    list<int> ls = {1,2,3,4,5,6};
    ls.reverse();
    for (auto e : ls)
    cout << e << " ";
    cout << endl;//6 5 4 3 2 1 
    return 0;
}