STL容器之＜list＞

测试环境

系统：ubuntu 22.04.2 LTS 64位
gcc版本：11.3.0
编辑器：vsCode 1.76.2

list介绍

1. 支持常数时间在容器的任何位置插入和删除元素。
2. 不支持随机访问，仅支持自增(++)和自减(–)操作。
3. 元素存储在不同且不相关的存储单元中。
4. 频繁插入、提取、移动和删除元素时效率较高。
5. 双向列表

头文件

#include 

模块类定义

_Tp：表示存储的元素数据类型
_Alloc：表示所存储分配器的类型，负责元素内存的分配和释放。可选参数，一般不使用。

template<typename _Tp, typename _Alloc = std::allocator<_Tp> > class list{};

对象构造

/*默认构造函数,没有元素*/
std::list<int> lstInt1;  
/*构造指定长度的对象，含有10个元素默认为0*/
std::list<int> lstInt2(10);
/*构造指定长度的指定值的对象，还有10个6*/
std::list<int> lstInt3(10,6);
/*复制拷贝构造函数，含有10个6*/
std::list<int> lstInt4(lstInt3);
/*指定迭代器范围构造对象*/
std::list<int> lstInt5(lstInt3.begin(),lstInt3.end());
/*移动构造函数，构造后lstInt5不可在使用*/
std::list<int> lstInt6(std::move(lstInt5));
/*初始化列表构造链表*/
std::list<int> lstInt7({1,2,3,4,5,6,7,8,9,0});

初始化

/*初始化列表初始化*/
lstInt1 = {1,2,3,4,5};
/*使用assign函数初始化,清空容器，并使用迭代器进行赋值*/
lstInt1.assign(lstInt6.cbegin(), lstInt6.cend());
/*赋值5个8*/
lstInt1.assign(5,8);
/*assign中使用初始化列表赋值*/
lstInt1.assign({8,7,6,5,4,3,2,1});

元素访问

函数名	返回值	功能
front()	首元素的引用	获取首元素，链表为空时返回值不确定
back()	元素的引用	获取末尾元素，链表为空时返回值不确定

/* 访问对象第一个元素和最后一个元素 */
std::cout << lstInt1.front() << " " << lstInt1.back() << std::endl;

元素插入和删除

函数	返回值	功能
clear()	无	清空所有元素
erase()	迭代器	清除指定位置的一个元素或通过迭代器指定范围内的元素
emplace()	无	在指定位置插入元素
emplace_front()	无	在链表头插入元素
emplace_back()	无	在链表末尾拆插入元素
insert()	迭代器或无	1）在指定位置插入1个元素。2）在指定位置插入指定数量的相同元素。3）通过指定迭代器范围在指定位置插入数据
pop_front()	无	删除链表头元素
push_front()	无	链表头插入元素
pop_back()	无	删除链表末尾元素
push_back()	无	在链表末尾添加元素
remove()	无	删除与指定值相同的所有元素
remove_if()	无	按用户自定义条件删除元素

/*在链表头插入元素*/
lstInt1.push_front(88);
/*在链表末尾插入元素*/
lstInt1.push_back(66);
/*指定位置插入元素*/
lstInt1.emplace(++lstInt1.begin(), 20);
/* 在容器头插入元素 */
lstInt1.emplace_front(10);
/* 在容器尾插入元素 */
lstInt1.emplace_back(10);
/*在指定位置插入元素*/
lstInt1.insert(lstInt1.begin(),66);
/*在指定位置插入指定数量的相同数据*/
lstInt1.insert(lstInt1.begin(),3,8);
/*在指定位置通过插入指定迭代器范围之间的数据*/
lstInt1.insert(lstInt1.begin(),  lstInt1.begin(), lstInt1.end());
/*在指定位置插入初始化列表中的数据*/
lstInt1.insert(lstInt1.begin(), {1,2,3});
/*删除链表头部元素*/
lstInt1.pop_front();
/*删除链表末尾元素*/
lstInt1.pop_back();
/* 清除指定位置的一个元素 */
lstInt1.erase(lstInt1.begin());
/* 清除从指定位置范围内的元素 */
lstInt1.erase(lstInt1.begin(), ++lstInt1.begin());
/*删除链表中与指定值相同的所有元素*/
lstInt1.remove(8);
/*删除大于10的所有元素*/
class delThanTen
{
public:
    bool operator()(int &element)
    {
        return element > 10;
    }
};
lstInt1.remove_if(delThanTen());
/*清空所有元素*/
lstInt1.clear();

容器大小

函数	返回值	功能
empty()	bool	判断当前容器是否为空，为空返回true，否则返回false
size()	std::size_t	获取当前容器中的元素数量
max_size()	std::size_t	返回容器的最大容量
reverse()	无	反转链表中的元素排列顺序
resize()	无	重新指定容器可以容纳的元素数量，新大小大于原本大小时超出部分可使用指定元素填充，如果新大小小于指定大小时会删除容器原本末尾的数据。

/*判断容器是否为空*/
std::cout << std::boolalpha << lstInt1.empty() << std::endl;
/*重新设置容器的大小*/
lstInt1.resize(30);
/*获取容器最大可分配的容量大小*/
std::cout << lstInt1.max_size() << std::endl;
/*获取当前容器中的元素数量*/
std::cout << lstInt1.size() << std::endl;
/*反转链表中的元素顺序*/
lstInt1.reverse();

迭代器

类型	功能
iterator	正向访问迭代器。从前向后访问元素，可以读取也可以修改
const_iterator	常量正向访问迭代器。从前向后访问元素，只能读取不能修改
reverse_iterator	逆向访问迭代器。从后向前访问元素，可以读取也可以修改
const_reverse_iterator	常量逆向访问迭代器。从后向前访问元素，只能读取不能修改

函数	返回值	功能
begin()	正向访问迭代器	返回指向list对象首元素所在位置的迭代器
end()	正向访问迭代器	返回指向list对象末尾元素的下一个位置的迭代器
cbegin()	常量正向访问迭代器	返回指向list对象首元素所在位置的常量迭代器
cend()	常量正向访问迭代器	返回指向list对象末尾元素的下一个位置的迭代器
rbegin()	逆向访问迭代器	返回指向list对象末尾元素位置的迭代器
rend()	逆向访问迭代器	返回指向list对象首元素的前一个位置的迭代器
crbegin()	常量逆向访问迭代器	返回指向list对象末尾元素位置的常量迭代器
crend()	常量逆向访问迭代器	返回指向list对象首元素的前一个位置的常量迭代器

std::list<int> lstTest4 = {10,11,12,13,14,15,16,17,18,19};
/*正向访问迭代器，每个元素+10，并打印输出（20 21 22 23 24 25 26 27 28 29）*/
std::list<int>::iterator itr;
for (itr = lstTest4.begin(); itr != lstTest4.end(); itr++)
{
    /* 修改元素值每个元素+10 */
    *itr += 10; 
    /* 访问元素 */
    std::cout << *itr << " ";
}
std::cout<<std::endl;
/*常量正向访问迭代器，并打印输出（20 21 22 23 24 25 26 27 28 29）*/
std::list<int>::const_iterator cItr;
for (cItr = lstTest4.begin(); cItr != lstTest4.end(); cItr++)
{
    /* 不允许修改值，编译报错 */
    //*cItr += 10; 
    /* 访问元素 */
    std::cout << *cItr << " ";
}
std::cout<<std::endl;
/*逆向访问迭代器，每个元素+100，并打印输出（129 128 127 126 125 124 123 122 121 120）*/
std::list<int>::reverse_iterator rItr;
for (rItr= lstTest4.rbegin(); rItr!= lstTest4.rend(); rItr++)
{
    /* 修改元素值 */
    *rItr += 100; 
    /* 访问元素 */
    std::cout << *rItr << " ";
}
std::cout<<std::endl;

/*常量逆向访问迭代器，并打印输出（129 128 127 126 125 124 123 122 121 120）*/
std::list<int>::const_reverse_iterator crItr;
for (crItr= lstTest4.crbegin(); crItr!= lstTest4.crend(); crItr++)
{
    /* 不允许修改元素值， 编译报错 */
    //*crItr += 100; 
    /* 访问元素 */
    std::cout << *crItr << " ";
}
std::cout<<std::endl;

其他函数

函数名	返回值	功能
merge()	无	合并两个链表，并按指定规则排序
sort()	无	按升序或用户指定的顺序排列元素
swap()	无	交换两个容器的元素
splice()	无	将一个链表中的元素添加到另一个链表中，并将原链表中的元素删除
unique()	无	删除相邻的重复元素，或者按指定规则删除元素

/*交互两个容器元素的值,无返回值*/
std::list<int> lstSwap1 = {1,2,3,4,5};
std::list<int> lstSwap2 = {5,4,3,2,1};
/*方式1， lstSwap1={5,4,3,2,1}, lstSwap2={1,2,3,4,5}*/
lstSwap1.swap(lstSwap2);
/*方式2，lstSwap1={1,2,3,4,5}, lstSwap2={5,4,3,2,1}*/
std::swap(lstSwap1,lstSwap2);
/*如果初始链表为无序的则合并后也是无序的*/
/*合并两个序列默认按升序排列，两个链表必须是按升序排列的*/
lstSwap1 = {1,2,3,4,5};
lstSwap2 = {1,2,3,4,5};
lstSwap1.merge(lstSwap2);
/*合并两个列表并按降序排列，两个链表必须是按降序排列的*/
lstSwap1 = {5,4,3,2,1};
lstSwap2 = {5,4,3,2,1};
lstSwap1.merge(lstSwap2,std::greater<int>());
/*将链表排序，无参数时默认升序排列*/
lstSwap1.sort(std::greater<int>());

std::list<int> lstSplice1 = {5,4,3,2,1};
std::list<int> lstSplice2 = {5,4,3,2,1};
/* 将lstSplice2的第二个元素加入到lstSplice1的第二个位置，并在lstSplice2中删除 */
lstSplice1.splice(++lstSplice1.begin(), lstSplice2, ++lstSplice2.begin());
/* 将lstSplice2的第二个元素加入到lstSplice1的第二个位置，并在lstSplice2中删除 */
lstSplice1.splice(lstSplice1.begin(), lstSplice2, ++lstSplice2.begin(), --lstSplice2.end());
/*将lstSplice2中的元素加入lstSplice1,并将lstSplice2中的元素删除*/
lstSplice1.splice(lstSplice1.end(), lstSplice2);
    
lstInt1 = {1,1,2,2,3,3,5,3,5};
/*删除相邻的重复元素*/
lstInt1.unique();
/*删除相连不相同的元素*/
std::not_equal_to<int> compare;
lstInt1.unique(compare);