C++STL——list容器及其常用操作（详解）

纵有疾风起，人生不言弃。本文篇幅较长，如有错误请不吝赐教，感谢支持。

一.list容器基本概念

链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。
每个结点包括两个部分：

• 一个是存储数据元素的数据域。
• 另一个是存储下一个结点地址的指针域。
  

list容器的数据结构是一个有头双向循环链表。链表其优缺点为：

• 采用动态存储分配，不会造成内存浪费和溢出
• 链表执行插入和删除操作十分方便，修改指针即可，不需要移动大量元素
• 链表灵活，但是空间和时间额外耗费较大

list容器的迭代器：
list容器不能像vector一样以普通指针作为迭代器，因为其节点不能保证在同一块连续的内存空间上。list迭代器必须有能力指向list的节点，并有能力进行正确的递增、递减、取值、成员存取操作。所谓”list正确的递增，递减、取值、成员取用”是指，递增时指向下一个节点，递减时指向上一个节点，取值时取的是节点的数据值，成员取用时取的是节点的成员。由于list还是一个双向链表，迭代器必须能够具备前移、后移的能力，所以list容器提供的是双向迭代器（Bidirectional Iterators）.

二.list容器的常用操作

list构造函数

注：使用list容器时，需包含头文件#include <list>

函数原型	解释
list <T> lst;	list采用模板实现类实现（显示实例化），对象的默认构造形式。
list(beg,end);	构造函数将[beg, end)区间中的元素拷贝给本身。
list(n,elem);	构造函数将n个elem拷贝给本身。
list(const list &lst);	拷贝构造函数。

实例：构造函数演示

#include <iostream>
using namespace std;
#include <list>//包含头文件
void printList(const list<int>& mylist)//形参使用const，避免被修改
{//const_iterator只读迭代器
	for (list<int>::const_iterator it = mylist.begin(); it != mylist.end(); ++it)
	{
		cout << *it << " ";
	}
	cout << endl;
}
void test()
{
	list<char> mylist1;//list采用模板实现类实现（显示实例化），对象的默认构造形式。
	list<int> mylist2(10, 6); //构造函数将n个elem拷贝给本身。
	list<int> mylist3(++mylist2.begin(), --mylist2.end());//构造函数将[beg, end)区间中的元素拷贝给本身。
	list<int> mylist4(mylist2);//拷贝构造函数

	printList(mylist2);
	printList(mylist3);
	printList(mylist4);
}
int main()
{
	test();
	return 0;
}

list迭代器获取

获取正向迭代器iterator：

函数原型	解释
iterator begin();	返回指向开始位置的迭代器，iterator是正向迭代器。只能使用++运算符从左向右遍历容器，每次沿容器向右移动一个元素。
const_iterator begin();	返回指向开始位置并且为常量的迭代器
const_iterator cbegin();	返回指向开始并且为常量的迭代器，const_iterator 常正向迭代器。函数作用：配合auto使用。
iterator end();	返回指向末尾元素的下一个位置的迭代器
const_iterator end();	返回指向末尾元素的下一个位置并且为常量的迭代器
const_iterator cend();	返回指向末尾元素的下一个位置的并且为常量的迭代器，函数作用：配合auto使用。

获取反向迭代器reverse_iterator：

函数原型	解释
reverse_iterator rbegin();	返回反向迭代器，指向末尾元素下一个位置，操作都是往相反反向，reverse_iterator 为反向迭代器。
const_reverse_iterator crbegin();	返回反向迭代器，指向末尾元素下一个位置，操作都是往相反反向，并且为常量属性，const_reverse_iterator 常反向迭代器。
reverse_iterator rend();	返回反向迭代器，指向开头元素的位置，操作都是往相反反向
const_reverse_iterator cre nd();	返回反向迭代器，指向开头元素的位置，操作都是往相反反向，并且为常量属性

迭代器都可以进行++操作。反向迭代器和正向迭代器的区别在于：
对正向迭代器进行++操作时，迭代器会指向容器中的后一个元素；
而对反向迭代器进行++操作时，迭代器会指向容器中的前一个元素。

#include <iostream>
using namespace std;
#include <list>//包含头文件
void printList1(const list<int>& mylist)//形参使用const，避免被修改
{//const_iterator只读迭代器
	for (auto it = mylist.begin(); it != mylist.end(); ++it)
	{
		cout << *it << "|";
	}
	cout << endl;
}
void printList2(const list<int>& mylist)//形参使用const，避免被修改
{//const_iterator只读迭代器
	for (auto it = mylist.rbegin(); it != mylist.rend(); ++it)
	{
		cout << *it << "|";
	}
	cout << endl;
}
void test()
{
	list<int> mylist;
	for (int i = 0; i < 5; i++)
	{
		mylist.push_back(i + 1);//1 2 3 4 5
	}
	printList1(mylist);
	printList2(mylist);
}
int main()
{
	test();
	return 0;
}

注意：begin函数和cbegin函数都可以返回const_iterator，那么为什么要两个函数呢？
因为begin函数有重载，无法配合auto（自动推导数据类型）使用，所以才多出一个cbegin函数。

list特性操作

函数原型	解释
size_t size() const;	返回容器的实际大小（已使用的空间）。
bool empty() const;	判断容器是否为空。
void clear();	清空容器。
void resize(size_t size);	把容器的实际大小置为size，如果size<实际大小，会截断多出的部分；如果size>实际大小，则以默认值0填充新位置
void resize(size_t size,const T &value);	把容器的实际大小置为size，如果size<实际大小，会截断多出的部分；如果size>实际大小，就用value填充。

实例：特性函数演示

#include <iostream>
using namespace std;
#include <list>//包含头文件
void printList(const list<int>& mylist)//形参使用const，避免被修改
{//const_iterator只读迭代器
	for (list<int>::const_iterator it = mylist.begin(); it != mylist.end(); ++it)
	{
		cout << *it << " ";
	}
	cout << endl;
}
void test()
{
	list<int> mylist;
	for (int i = 0; i < 5; i++)
	{
		mylist.push_back(i + 1);
	}

	cout << "size:" << mylist.size() << endl;//5

	cout << mylist.empty() << endl;//0
	if (mylist.empty())
	{
		cout << "空" << endl;
	}
	else
	{
		cout << "不为空" << endl;
	}

	mylist.resize(3);
	printList(mylist);//1 2 3

	mylist.resize(5);//重新指定容器的长度为num，若容器变长，则以默认值填充新位置。
	printList(mylist);//1 2 3 0 0

	mylist .resize(10, 6);//如果容器变长，也可以用value填充
	printList(mylist);//1 2 3 0 0 6 6 6 6 6 
}
int main()
{
	test();
	return 0;
}

list元素操作

函数原型	解释
T& front();	返回第一个元素。
T& back();	返回最后一个元素。

list赋值操作

作用：通过重载赋值运算符operator=和成员函数assign()，给已存在的容器赋值，将覆盖容器中原有的内容。

函数原型	解释
list assign(beg, end);	将[beg, end)区间中的数据拷贝赋值给本身。
void assign(const size_t n, const T& value);	将n个elem拷贝赋值给本身。
list& operator=(const list &lst);	重载等号操作符，把容器l赋值给当前容器。

实例：赋值操作演示

#include <iostream>
using namespace std;
#include <list>//包含头文件
#include<algorithm>
void printList(const list<int>& mylist)//形参使用const，避免被修改
{//const_iterator只读迭代器
	for (list<int>::const_iterator it = mylist.begin(); it != mylist.end(); ++it)
	{
		cout << *it << " ";
	}
	cout << endl;
}

void test()
{
	list<int> mylist;
	mylist.assign(10, 10);
	printList(mylist);

	list<int> mylist2;
	mylist2.assign(mylist.begin()++, mylist.end()--);
	printList(mylist2);

	cout << mylist.front() << endl;
	cout << mylist.back() << endl;
}
int main()
{
	test();
	return 0;
}

list的交换、反转、排序、归并操作

函数原型	解释
void swap(list<T> &l);	把当前容器与l交换，交换的是链表结点的地址。
void reverse();	反转链表。
void sort();	对容器中的元素进行升序排序。
void sort(_Pr2 _Pred);	对容器中的元素进行排序，排序的方法由_Pred决定（二元函数）。
void merge(list< T> &l);	采用归并法合并两个已排序的list容器，合并后的list容器仍是有序的。

实例：list的交换、反转、排序、归并操作演示

#include <iostream>
using namespace std;
#include <list>//包含头文件
#include<algorithm>
void printList(const list<int>& mylist)//形参使用const，避免被修改
{//const_iterator只读迭代器
	for (list<int>::const_iterator it = mylist.begin(); it != mylist.end(); ++it)
	{
		cout << *it << " ";
	}
	cout << endl;
}
bool myfunc2(int v1, int v2)
{
	return v1 > v2;
}
void test()
{
	list<int> mylist;
	for (int i = 0; i < 5; i++)
	{
		mylist.push_back(i + 10);//10 11 12 13 14
	}
	list<int> mylist2;
	for (int i = 0; i < 5; i++)
	{
		mylist2.push_back(i);//0 1 2 3 4
	}

	mylist2.swap(mylist); //把当前容器mylist2与mylist交换，交换的是链表结点的地址。
	printList(mylist2);//10 11 12 13 14

	mylist2.reverse();//反转链表

	printList(mylist2);//14 13 12 11 10

	//注意：list容器不能使用sort算法,list容器有自己专属的sort成员函数
	//sort(mylist.begin(), mylist.end());
	
	mylist2.sort(myfunc2);//借助myfunc2函数进行比较，然后sort降序排列
	printList(mylist2);//14 13 12 11 10

	mylist2.sort();//mylist2链表使用sort函数默认升序排列
	printList(mylist2);//10 11 12 13 14

	mylist.sort();//mylist链表使用sort函数默认升序排列
	printList(mylist);//0 1 2 3 4 

	mylist2.merge(mylist); //采用归并法合并两个已排序的list容器，合并后的list容器仍是有序的
	printList(mylist2); //0 1 2 3 4 10 11 12 13 14

}
int main()
{
	test();
	return 0;
}

list比较操作

函数原型	解释
bool operator == (const vector<T> & l) const;	重载==运算符，判断当前链表与l是否相等
bool operator != (const vector<T> & l) const;	重载！=运算符，判断当前链表与l是否不相等

list插入和删除操作

函数原型	解释
void push_front(const T& ele);	在容器头部插入一个数据
void push_back(const T& ele);	尾部插入元素ele
void pop_front();	删除容器第一个数据
void pop_back();	删除最后一个元素
iterator insert(iterator pos, const T& value);	在指定位置插入一个元素，返回指向插入元素的迭代器。
iterator insert(pos,n,elem);	在pos位置插入n个elem数据，返回指向第一个插入元素的迭代器。
iterator insert(iterator pos, iterator first, iterator last);	在指定位置插入一个区间的元素，返回指向第一个插入元素的迭代器。
iterator erase(iterator pos);	删除指定位置的元素，返回下一个有效的迭代器。
iterator erase(iterator first, iterator last);	删除指定区间的元素，返回下一个有效的迭代器。
splice(iterator pos, const vector< T> & l);	把另一个链表连接到当前链表pos位置处。
splice(iterator pos, const vector< T> & l, iterator first, iterator last);	把另一个链表指定的区间连接到当前链表pos位置处。
splice(iterator pos, const vector< T> & l, iterator first);	把另一个链表从first开始的结点连接到当前链表pos位置处。
void remove(const T& value);	删除链表中所有值等于value的元素。
void remove_if(_Pr1 _Pred);	删除链表中满足条件的元素，参数_Pred是一元函数。
void unique();	删除链表中相邻的重复元素，只保留一个。

list插入和删除操作演示：

#include <iostream>
using namespace std;
#include <vector>
#include <list>//包含头文件
void printList(const list<int>& mylist)//形参使用const，避免被修改
{//const_iterator只读迭代器
	for (list<int>::const_iterator it = mylist.begin(); it != mylist.end(); ++it)
	{
		cout << *it << " ";
	}
	cout << endl;
}
bool myfunc(int val)
{
	return val > 300;
}
void test()
{
	list<int> mylist;
	mylist.push_back(10);//在容器尾部插入一个数据
	mylist.push_back(20);
	mylist.push_back(30);
	mylist.push_back(40);
	mylist.push_back(50);
	
	mylist.push_front(100);//在容器头部插入一个数据
	mylist.push_front(200);
	mylist.push_front(300);
	mylist.push_front(400);

	printList(mylist);//400 300 200 100 10 20 30 40 50
	cout << "------------------" << endl;

	list<int>::const_iterator it = mylist.insert(mylist.begin(), 2, 0);//在pos位置插入n个elem数据
	cout << *it << endl;//返回指向第一个插入元素的迭代器。
	cout << "------------------" << endl;

	vector<int> v;
	v.push_back(1000);
	v.push_back(2000);
	v.push_back(3000);

	mylist.insert(mylist.begin(), v.begin(), v.end()); //在指定位置插入一个区间的元素，返回指向第一个插入元素的迭代器
	printList(mylist);//1000 2000 3000 400 300 200 100 10 20 30 40 50
	cout << "------------------" << endl;

	mylist.erase(mylist.begin());//删除第一个元素
	printList(mylist); //2000 3000 400 300 200 100 10 20 30 40 50
	cout << "------------------" << endl;

	list<int> mylist2(6,6);

	mylist.splice(mylist.end(),mylist2);//将mylist2链接到mylist后
	printList(mylist);//2000 3000 400 300 200 100 10 20 30 40 50 6 6 6 6 6 6
	cout << "------------------" << endl;

	mylist.remove(300); //删除链表中所有值等于300的元素
	printList(mylist);//2000 3000 400 200 100 10 20 30 40 50 6 6 6 6 6 6
	cout << "------------------" << endl;

	mylist.remove_if(myfunc);//删除链表中所有值大于300的元素
	printList(mylist);// 200 100 10 20 30 40 50 6 6 6 6 6 6
	cout << "------------------" << endl;
}
int main()
{
	test();
	return 0;
}