C++ STL（七）：list容器

---

1 list基本概念

作用：链表，链式存储数据。STL中的链表是双向循环链表。

链表：链表list是物理存储单元上非连续的存储结构，数据元素的逻辑顺序通过链表中的指针链接实现。链表由一系列节点组成。

节点的组成：
①数据域：存储数据元素；
②指针域：存储下一个节点的地址（指针指向下一个节点）。

---

list容器的迭代器：
链表采用不连续的存储结构，故链表list的迭代器只支持前移和后移（不支持跳跃式访问），属于双向迭代器。

注：list容器插入或删除元素时，不会导致原有迭代器失效；
vector容器插入或删除元素时，会导致原有迭代器失效。

---

list容器的数据结构：
STL中的list容器，采用双向循环链表的数据结构：
第1个节点的前继节点为最后1个节点（第1个节点的prev指针指向最后1个节点）；
最后1个节点的后继节点为第1个节点（最后1个节点的next指针指向第1个节点）。

push_front()：头插法插入节点。
pop_front()：头删法删除节点。
push_back()：尾插法插入节点。
pop_back()：尾删法删除节点。
front()：获取list容器的第1个节点。
back()：获取list容器的最后1个节点。
begin()：获取起始迭代器，指向容器中的第1个节点。
end()：获取结束迭代器，指向容器中的最后1个节点的下一个位置。

---

list的优缺点：
优点：
①采用动态存储分配，不会造成内存浪费或溢出；
②链表，可在任意位置插入或删除元素，只需修改指针指向，无需移动大量元素。

缺点：
①链表包括数据域和指针域，占用内存空间较大；
②元素访问/遍历速度较慢。

注1：链表增删快、查询慢；数组增删慢、查询快。
注2：list和vector是C++ STL中最常用的容器，各有优缺点。

---

2 list构造函数

作用：创建list容器。

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

函数原型：
（1）list<T> lst;：默认无参构造函数，采用类模板实现。
（2）list(lst.begin(), lst.end());：拷贝容器对象lst的[begin(), end())区间（左闭右开，包左不包右）的元素进行初始化。
（3）list(n, elem);：有参构造函数，使用n个elem元素进行初始化。
（4）list(const list&lst);：拷贝构造函数，使用已有list对象初始化新的对象。

示例：list构造函数

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


//函数模板：遍历list容器的通用函数
template<typename T>
void printList(const list<T> &lst) {	//形参使用const，避免被修改
	//形参使用const后，遍历时需使用只读迭代器const_iterator
	//使用typename关键字，防止编译器报错：C2760（语法错误，意外标记“标识符”）
	for (typename list<T>::const_iterator it = lst.begin(); it != lst.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}

int main() {
	//1.无参构造函数
	list<int> lst;
	lst.push_back(5);
	lst.push_back(7);
	lst.push_back(9);
	lst.push_front(3);
	lst.push_front(1);
	printList<int>(lst);	//1 3 5 7 9

	//2.区间构造
	list<int> l1(lst.begin(), lst.end());
	printList<int>(l1);		//1 3 5 7 9

	//3.拷贝构造
	list<int> l2(l1);
	printList<int>(l2);		//1 3 5 7 9

	//4.n个elem元素构造
	list<int> l3(5, 6);
	printList<int>(l3);		//6 6 6 6 6

	return 0;
}

---

3 list赋值【operator=、assign()】和交换【swap()】

赋值操作：通过重载赋值运算符operator=和成员函数assign()，对list容器进行赋值。

函数原型：
（1）list& operator=(const list &lst);：重载赋值运算符，使用目标list容器，对当前list容器赋值。
（2）assign(begin, end);：拷贝目标list容器中[begin(), end())区间（左闭右开，包左不包右）的元素，对当前list容器赋值。
（3）assign(n, elem);：使用n个elem元素，对当前list容器赋值。

---

交换操作：实现list容器的交换。
swap(lst);：将目标list容器lst与自身的元素互换。

示例：list赋值与交换

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


//函数模板：遍历list容器的通用函数
template<typename T>
void printList(const list<T>& lst) {	//形参使用const，避免被修改
	//形参使用const后，遍历时需使用只读迭代器const_iterator
	//使用typename关键字，防止编译器报错：C2760（语法错误，意外标记“标识符”）
	for (typename list<T>::const_iterator it = lst.begin(); it != lst.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}

int main() {
	//无参构造函数
	list<int> lst;
	lst.push_back(5);
	lst.push_back(7);
	lst.push_back(9);
	lst.push_front(3);
	lst.push_front(1);
	printList<int>(lst);	//1 3 5 7 9

	//1.重载赋值运算符
	list<int> l1;
	l1 = lst;		
	printList<int>(l1);		//1 3 5 7 9

	//2.assign()赋值
	list<int> l2;
	l2.assign(lst.begin(), lst.end());
	printList<int>(l2);		//1 3 5 7 9

	//3.n个elem元素：assign(n, elem)
	list<int> l3;
	l3.assign(3, 6);
	printList<int>(l3);		//6 6 6

	/* 容器交换 */
	cout << "交换前l2:" << endl;
	printList<int>(l2);		//1 3 5 7 9
	cout << "交换前l3:" << endl;
	printList<int>(l3);		//6 6 6

	l3.swap(l2);

	cout << "交换后l2:" << endl;
	printList<int>(l2);		//6 6 6
	cout << "交换后l3:" << endl;
	printList<int>(l3);		//1 3 5 7 9

	return 0;
}

---

4 list大小操作【size()、resize()】

作用：操作list容器的大小（即元素个数）。

函数原型：
（1）empty();：判断容器是否为空。
（2）size();：获取容器的大小，即元素个数。
（3）resize(int num);：重新指定容器的长度为num。
若容器变长，则以默认值0填充新位置；若容器变短，则容器末尾超出新长度的元素被删除。
（4）resize(int num, elem); ：重新指定容器的长度为num。
若容器变长，则以指定值elem填充新位置；若容器变短，则容器末尾超出新长度的元素被删除。

注：list容器不存在容量的概念，即不存在capacity()成员函数。
list支持动态存储分配，通过维护指针域允许随时插入或删除节点。

示例：

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

//函数模板：遍历list容器的通用函数
template<typename T>
void printList(const list<T>& lst) {	//形参使用const，避免被修改
	//形参使用const后，遍历时需使用只读迭代器const_iterator
	//使用typename关键字，防止编译器报错：C2760（语法错误，意外标记“标识符”）
	for (typename list<T>::const_iterator it = lst.begin(); it != lst.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}

int main() {
	//无参构造函数
	list<int> lst;
	lst.push_back(5);
	lst.push_back(7);
	lst.push_back(9);
	lst.push_front(3);
	lst.push_front(1);
	printList<int>(lst);	//1 3 5 7 9

	//size()：容器大小
	cout << "容器大小：" << lst.size() << endl;		//5

	//empty()：判断容器是否为空
	cout << (lst.empty() ? "空" : "非空") << endl;	//非空

	//resize(int num);：重新指定容器的长度为num。
	//若容器变长，则以默认值0填充新位置；若容器变短，则容器末尾超出新长度的元素被删除。
	lst.resize(10);
	printList<int>(lst);	//1 3 5 7 9 0 0 0 0 0

	lst.resize(3);
	printList<int>(lst);	//1 3 5

	//resize(int num, elem); ：重新指定容器的长度为num。
	//若容器变长，则以指定值elem填充新位置；若容器变短，则容器末尾超出新长度的元素被删除。
	lst.resize(8, 6);
	printList<int>(lst);	//1 3 5 6 6 6 6 6

	return 0;
}

---

5 list插入【push_front()、push_back()、insert()】和删除【pop_front()、pop_back()、erase()、clear()、remove()】

（1）list容器插入元素：使用成员函数push_front(..)、push_back(..)、insert(..)向list容器插入元素。

函数原型：
①push_front(elem);：头插法，向list容器的头部插入元素elem。
②push_back(elem);：尾插法，向list容器的尾部插入元素elem。
③insert(const_iterator pos, elem);：迭代器指向位置pos插入元素elem
④insert(const_iterator pos, int n, elem);：迭代器指向位置pos插入n个元素elem。
⑤insert(const_iterator pos, const_iterator begin, const_iterator end);：迭代器指向位置pos插入[begin(), end())区间（左闭右开，包左不包右）的元素，无返回值。

---

（2）list容器删除元素：使用成员函数pop_front()、pop_back(..)、erase(..)、clear(..)删除list容器中的元素。

函数原型：
①pop_front()：头删法，删除list容器头部的第1个元素。
②pop_back();：尾删法，删除list容器尾部的最后1个元素。
③erase(const_iterator pos);：删除迭代器指向位置的元素。
④erase(const_iterator start, const_iterator end);：删除迭代器指向位置[start, end)区间的所有元素。
⑤clear();：清空容器中的所有元素。
⑥remove(elem);：删除容器中与指定值elem匹配的所有元素。

注1：清空容器的所有元素，lst.clear();等价于lst.erase(lst.begin(), lst.end());。
注2：插入元素insert(..)、删除元素erase(..)均需要迭代器对象作为参数。

示例：list容器插入与删除元素

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

//函数模板：遍历list容器的通用函数
template<typename T>
void printList(const list<T>& lst) {	//形参使用const，避免被修改
	//形参使用const后，遍历时需使用只读迭代器const_iterator
	//使用typename关键字，防止编译器报错：C2760（语法错误，意外标记“标识符”）
	for (typename list<T>::const_iterator it = lst.begin(); it != lst.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}

int main() {
	list<int> lst;
	//尾插
	lst.push_back(5);
	lst.push_back(7);
	lst.push_back(9);
	
	//头插
	lst.push_front(3);
	lst.push_front(1);
	printList<int>(lst);	//1 3 5 7 9

	//尾删
	lst.pop_back();
	printList<int>(lst);	//1 3 5 7

	//头删
	lst.pop_front();
	printList<int>(lst);	//3 5 7

	//insert()-插入单个元素
	//在第0个与第1个索引位置插入元素4
	lst.insert(++lst.begin(), 4);
	printList<int>(lst);	//3 4 5 7

	//erase()-删除单个元素
	//删除第1个索引位置的元素
	lst.erase(++lst.begin());
	printList<int>(lst);	//3 5 7

	//insert()-插入多个元素
	//在第0个索引位置前插入3个1
	lst.insert(lst.begin(), 3 , 0);
	printList<int>(lst);	//0 0 0 3 5 7


	list<int> l1;
	//insert()-插入区间元素
	l1.insert(l1.begin(), lst.begin(), lst.end());
	printList<int>(l1);		//0 0 0 3 5 7

	//remove()-删除指定值的元素
	l1.remove(0);
	printList<int>(l1);		//3 5 7

	//erase()-删除区间元素
	l1.erase(l1.begin(), l1.end());
	printList<int>(l1);		//（空）

	//remove()-清空元素
	lst.clear();
	printList<int>(lst);	//（空）

	return 0;
}

---

6 list数据存取【front()、back()】

作用：对list容器中数据进行存取。

注1：链表底层采用非连续线性的内存空间，且仅支持双向迭代器（只能前移和后移），无法使用索引跳跃式地访问元素。故不支持重载赋值运算符operator[]和成员函数at(int index)跳跃式地访问指定索引位置元素。
注2：list容器支持双向迭代器，允许前移it--;和后移it++;；
list容器不支持随机访问迭代器，不允许跳跃式移动it += 1;或it -= 2;，否则编译器报错：没有与操作数匹配的 += 或 -= 运算符。

函数原型：
front();：返回容器的第1个元素。
back();：返回容器的最后1个元素。

示例：

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

//函数模板：遍历list容器的通用函数
template<typename T>
void printList(const list<T>& lst) {	//形参使用const，避免被修改
	//形参使用const后，遍历时需使用只读迭代器const_iterator
	//使用typename关键字，防止编译器报错：C2760（语法错误，意外标记“标识符”）
	for (typename list<T>::const_iterator it = lst.begin(); it != lst.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}

int main() {
	list<int> lst;
	//尾插
	lst.push_back(1);
	lst.push_back(3);
	lst.push_back(5);
	lst.push_back(7);
	lst.push_back(9);
	printList<int>(lst);	//1 3 5 7 9

	cout << "第1个元素：" << lst.front() << endl;	//1
	cout << "最后1个元素：" << lst.back() << endl;	//9

	//修改元素
	lst.front() = 0;
	lst.back() = 100;
	printList<int>(lst);	//0 3 5 7 100


	//list容器支持双向迭代器，允许前移和后移
	list<int>::iterator it = lst.begin();
	it++;	//允许后移
	it--;	//允许前移

	//list容器不支持随机访问迭代器，不允许跳跃式移动
	//it += 1;	//报错：没有与操作数匹配的 += 运算符
	//it += 3;	//报错：没有与操作数匹配的 += 运算符
	//it -= 1;	//报错：没有与操作数匹配的 -= 运算符
	//it -= 3;	//报错：没有与操作数匹配的 -= 运算符

	return 0;
}

---

7 list反转【reverse()】和排序【sort()】

（1）list反转
reverse();：将容器中的元素反转。

---

（2）list排序
sort();：将容器中的数据进行排序，默认升序排序。

注1：链表排序的sort()函数是list容器的成员函数，而不是标准算法头文件<algorithm>的全局函数。
注2：可通过回调函数或仿函数实现sort()函数按自定义规则排序。

---

回调函数-实现自定义排序：

//回调函数
bool myCompare(int val1, int val2){
	//return val1 < val2;	//升序排序
	return val1 > val2;		//降序排序
}

//使用回调函数，按自定义规则排序
lst.sort(myCompare);

---

仿函数/函数对象-实现自定义排序：

//函数对象/仿函数
class MyCompare {
public:
	//重载函数调用运算符()
	bool operator()(int val1, int val2) {
		//return val1 < val2;	//升序排序
		return val1 > val2;		//降序排序
	}
};

//使用仿函数/函数对象，按自定义规则排序
//MyCompare mc;
//lst.sort(mc);			//函数对象mc
lst.sort(MyCompare());	//匿名函数对象MyCompare()

---

示例：使用回调函数和仿函数，实现内置数据类型排序

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

//函数模板：遍历list容器的通用函数
template<typename T>
void printList(const list<T>& lst) {	//形参使用const，避免被修改
	//形参使用const后，遍历时需使用只读迭代器const_iterator
	//使用typename关键字，防止编译器报错：C2760（语法错误，意外标记“标识符”）
	for (typename list<T>::const_iterator it = lst.begin(); it != lst.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}

//反转
void func1() {
	list<int> lst;
	//尾插
	lst.push_back(5);
	lst.push_back(8);
	lst.push_back(3);
	lst.push_back(6);
	lst.push_back(1);

	cout << "反转前：" << endl;
	printList<int>(lst);	//5 8 3 6 1

	//反转
	lst.reverse();
	cout << "反转后：" << endl;
	printList<int>(lst);	//1 6 3 8 5
}

//回调函数-自定义排序规则
bool myCompare(int val1, int val2) {
	//return val1 < val2;	//升序排序
	return val1 > val2;	//降序排序
}

//函数对象/仿函数-自定义排序规则
class MyCompare {
public:
	//重载函数调用运算符()
	bool operator()(int val1, int val2) {
		//return val1 < val2;	//升序排序
		return val1 > val2;	//降序排序
	}
};


//排序
void func2() {
	list<int> lst;
	//尾插
	lst.push_back(5);
	lst.push_back(8);
	lst.push_back(3);
	lst.push_back(6);
	lst.push_back(1);

	cout << "排序前：" << endl;
	printList<int>(lst);	//5 8 3 6 1

	//默认升序排序
	lst.sort();
	cout << "升序排序后：" << endl;
	printList<int>(lst);	//1 3 5 6 8

	//降序排序：使用回调函数
	//lst.sort(myCompare);

	//降序排序：使用仿函数/函数对象
	//MyCompare mc;
	//lst.sort(mc);			//函数对象
	lst.sort(MyCompare());	//匿名函数对象

	cout << "降序排序后：" << endl;
	printList<int>(lst);	//8 6 5 3 1
}

int main() {
	//func1();
	func2();

	return 0;
}

---

8 案例练习：自定义数据类型的排序

注1：对于自定义数据类型，必须指定排序规则，否则编译器不清楚如何排序。
注2：高级排序是在排序规则的基础上额外制定一次或多次逻辑规则。

案例描述：
对自定义数据类型Person进行排序，Person类包括姓名、成绩、年龄等成员属性。
排序规则：先按成绩降序排序，再按年龄升序排序。

示例：自定义数据类型Person的排序

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

class Person {
public:
	string name;
	int score;
	int age;

	Person(string name, int score, int age) {
		this->name = name;
		this->score = score;
		this->age = age;
	}
};

//排序规则的回调函数
bool myCompare1(Person p1, Person p2) {
	//先按照成绩socre降序排序
	if (p1.score == p2.score) {
		//成绩socre相同时，再按年龄age升序排序
		return p1.age < p2.age;
	}
	else {
		return p1.score > p2.score;
	}
}

//排序规则的回调函数：使用三目运算符简化
bool myCompare2(Person p1, Person p2) {
	//成绩不等时，按成绩降序排序
	//成绩相等时，按年龄升序排序
	return (p1.score == p2.score) ? (p1.age < p2.age) : (p1.score > p2.score);
}

int main() {
	list<Person> personList;

	//创建Person对象
	Person p1("普通青年", 60, 20);
	Person p2("聪明青年", 100, 20);
	Person p3("油腻中年", 60, 40);
	Person p4("勤奋青年", 80, 20);
	Person p5("摸鱼青年", 60, 30);
	Person p6("天才少年", 100, 15);

	//向list容器添加Person对象
	personList.push_back(p1);
	personList.push_back(p2);
	personList.push_back(p3);
	personList.push_back(p4);
	personList.push_back(p5);
	personList.push_back(p6);

	for (list<Person>::iterator it = personList.begin(); it != personList.end(); it++) {
		cout << "姓名：" << (*it).name << "， "
			<< "成绩：" << it->score << "， "
			<< "年龄：" << it->age << endl;
	}

	cout << "----------排序后-----------" << endl;

	//自定义排序：调用回调函数
	//personList.sort(myCompare1);
	personList.sort(myCompare2);

	for (list<Person>::iterator it = personList.begin(); it != personList.end(); it++) {
		cout << "姓名：" << (*it).name << "，"
			<< "成绩：" << it->score << "，"
			<< "年龄：" << it->age << endl;
	}
}

输出结果：

姓名：普通青年， 成绩：60， 年龄：20
姓名：聪明青年， 成绩：100， 年龄：20
姓名：油腻中年， 成绩：60， 年龄：40
姓名：勤奋青年， 成绩：80， 年龄：20
姓名：摸鱼青年， 成绩：60， 年龄：30
姓名：天才少年， 成绩：100， 年龄：15
----------排序后-----------
姓名：天才少年，成绩：100，年龄：15
姓名：聪明青年，成绩：100，年龄：20
姓名：勤奋青年，成绩：80，年龄：20
姓名：普通青年，成绩：60，年龄：20
姓名：摸鱼青年，成绩：60，年龄：30
姓名：油腻中年，成绩：60，年龄：40