熬夜爆肝！C++核心STL容器知识点汇总整理【3W字干货预警 建议收藏】_stl知识点总结百度网盘

return 0;

}

总结：


* 尾插 — push\_back
* 尾删 — pop\_back
* 插入 — insert (位置迭代器)
* 删除 — erase （位置迭代器）
* 清空 — clear


##### 1.1.6 vector数据存取


**功能描述：**


* 对vector中的数据的存取操作


**函数原型：**


* `at(int idx);` //返回索引idx所指的数据
* `operator[];` //返回索引idx所指的数据
* `front();` //返回容器中第一个数据元素
* `back();` //返回容器中最后一个数据元素


**示例：**

#include

void test01()
{
vectorv1;
for (int i = 0; i < 10; i++)
{
v1.push_back(i);
}

for (int i = 0; i < v1.size(); i++)
{
	cout << v1[i] << " ";
}
cout << endl;

for (int i = 0; i < v1.size(); i++)
{
	cout << v1.at(i) << " ";
}
cout << endl;

cout << "v1的第一个元素为： " << v1.front() << endl;
cout << "v1的最后一个元素为： " << v1.back() << endl;

}

int main() {

test01();

system("pause");

return 0;

}

总结：


* 除了用迭代器获取vector容器中元素，[ ]和at也可以
* front返回容器第一个元素
* back返回容器最后一个元素


##### 1.1.7 vector互换容器


**功能描述：**


* 实现两个容器内元素进行互换


**函数原型：**


* `swap(vec);` // 将vec与本身的元素互换


**示例：**

#include

void printVector(vector& v) {

for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
	cout << *it << " ";
}
cout << endl;

}

void test01()
{
vectorv1;
for (int i = 0; i < 10; i++)
{
v1.push_back(i);
}
printVector(v1);

vector<int>v2;
for (int i = 10; i > 0; i--)
{
	v2.push_back(i);
}
printVector(v2);

//互换容器
cout << "互换后" << endl;
v1.swap(v2);
printVector(v1);
printVector(v2);

}

void test02()
{
vector v;
for (int i = 0; i < 100000; i++) {
v.push_back(i);
}

cout << "v的容量为：" << v.capacity() << endl;
cout << "v的大小为：" << v.size() << endl;

v.resize(3);

cout << "v的容量为：" << v.capacity() << endl;
cout << "v的大小为：" << v.size() << endl;

//收缩内存
vector<int>(v).swap(v); //匿名对象

cout << "v的容量为：" << v.capacity() << endl;
cout << "v的大小为：" << v.size() << endl;

}

int main() {

test01();

test02();

system("pause");

return 0;

}

总结：swap可以使两个容器互换，可以达到实用的收缩内存效果


##### 1.1.8 vector预留空间


**功能描述：**


* 减少vector在动态扩展容量时的扩展次数


**函数原型：**


* `reserve(int len);`//容器预留len个元素长度，预留位置不初始化，元素不可访问。


**示例：**

#include

void test01()
{
vector v;

//预留空间
v.reserve(100000);

int num = 0;
int* p = NULL;
for (int i = 0; i < 100000; i++) {
	v.push_back(i);
	if (p != &v[0]) {
		p = &v[0];
		num++;
	}
}

cout << "num:" << num << endl;

}

int main() {

test01();

system("pause");

return 0;

}

总结：如果数据量较大，可以一开始利用reserve预留空间


#### 1.2 deque容器


##### 1.2.1 deque容器基本概念


**功能：**


* 双端数组，可以对头端进行插入删除操作


**deque与vector区别：**


* vector对于头部的插入删除效率低，数据量越大，效率越低
* deque相对而言，对头部的插入删除速度回比vector快
* vector访问元素时的速度会比deque快,这和两者内部实现有关


![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2ttFsUFI-1630623679109)(assets/clip_image002-1547547642923.jpg)]](https://img-blog.csdnimg.cn/da8cb1a5d6374d15bc1e297c61f02f3d.jpg?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBARHJhZ29u5bCR5bm0,size_15,color_FFFFFF,t_70,g_se,x_16)


deque内部工作原理:


deque内部有个**中控器**，维护每段缓冲区中的内容，缓冲区中存放真实数据


中控器维护的是每个缓冲区的地址，使得使用deque时像一片连续的内存空间


![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4952yvMs-1630623679111)(assets/clip_image002-1547547896341.jpg)]](https://img-blog.csdnimg.cn/5c8bcb9e517b445aaca766664f840fc2.jpg?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBARHJhZ29u5bCR5bm0,size_14,color_FFFFFF,t_70,g_se,x_16)


* deque容器的迭代器也是支持随机访问的


##### 1.2.2 deque构造函数


**功能描述：**


* deque容器构造


**函数原型：**


* `deque<T>` deqT; //默认构造形式
* `deque(beg, end);` //构造函数将[beg, end)区间中的元素拷贝给本身。
* `deque(n, elem);` //构造函数将n个elem拷贝给本身。
* `deque(const deque &deq);` //拷贝构造函数


**示例：**

#include

void printDeque(const deque& d)
{
for (deque::const_iterator it = d.begin(); it != d.end(); it++) {
cout << *it << " ";

}
cout << endl;

}
//deque构造
void test01() {

deque<int> d1; //无参构造函数
for (int i = 0; i < 10; i++)
{
	d1.push_back(i);
}
printDeque(d1);
deque<int> d2(d1.begin(),d1.end());
printDeque(d2);

deque<int>d3(10,100);
printDeque(d3);

deque<int>d4 = d3;
printDeque(d4);

}

int main() {

test01();

system("pause");

return 0;

}

\*\*总结：\*\*deque容器和vector容器的构造方式几乎一致，灵活使用即可


##### 1.2.3 deque赋值操作


**功能描述：**


* 给deque容器进行赋值


**函数原型：**


* `deque& operator=(const deque &deq);` //重载等号操作符
* `assign(beg, end);` //将[beg, end)区间中的数据拷贝赋值给本身。
* `assign(n, elem);` //将n个elem拷贝赋值给本身。


**示例：**

#include

void printDeque(const deque& d)
{
for (deque::const_iterator it = d.begin(); it != d.end(); it++) {
cout << *it << " ";

}
cout << endl;

}
//赋值操作
void test01()
{
deque d1;
for (int i = 0; i < 10; i++)
{
d1.push_back(i);
}
printDeque(d1);

deque<int>d2;
d2 = d1;
printDeque(d2);

deque<int>d3;
d3.assign(d1.begin(), d1.end());
printDeque(d3);

deque<int>d4;
d4.assign(10, 100);
printDeque(d4);

}

int main() {

test01();

system("pause");

return 0;

}

##### 1.2.4 deque大小操作


**功能描述：**


* 对deque容器的大小进行操作


**函数原型：**


* `deque.empty();` //判断容器是否为空
* `deque.size();` //返回容器中元素的个数
* `deque.resize(num);` //重新指定容器的长度为num,若容器变长，则以默认值填充新位置。

 ​ //如果容器变短，则末尾超出容器长度的元素被删除。
* `deque.resize(num, elem);` //重新指定容器的长度为num,若容器变长，则以elem值填充新位置。

 ​ //如果容器变短，则末尾超出容器长度的元素被删除。


**示例：**

#include

void printDeque(const deque& d)
{
for (deque::const_iterator it = d.begin(); it != d.end(); it++) {
cout << *it << " ";

}
cout << endl;

}

//大小操作
void test01()
{
deque d1;
for (int i = 0; i < 10; i++)
{
d1.push_back(i);
}
printDeque(d1);

//判断容器是否为空
if (d1.empty()) {
	cout << "d1为空!" << endl;
}
else {
	cout << "d1不为空!" << endl;
	//统计大小
	cout << "d1的大小为：" << d1.size() << endl;
}

//重新指定大小
d1.resize(15, 1);
printDeque(d1);

d1.resize(5);
printDeque(d1);

}

int main() {

test01();

system("pause");

return 0;

}

总结：


* deque没有容量的概念
* 判断是否为空 — empty
* 返回元素个数 — size
* 重新指定个数 — resize


##### 1.2.5 deque 插入和删除


**功能描述：**


* 向deque容器中插入和删除数据


**函数原型：**


两端插入操作：


* `push_back(elem);` //在容器尾部添加一个数据
* `push_front(elem);` //在容器头部插入一个数据
* `pop_back();` //删除容器最后一个数据
* `pop_front();` //删除容器第一个数据


指定位置操作：


* `insert(pos,elem);` //在pos位置插入一个elem元素的拷贝，返回新数据的位置。
* `insert(pos,n,elem);` //在pos位置插入n个elem数据，无返回值。
* `insert(pos,beg,end);` //在pos位置插入[beg,end)区间的数据，无返回值。
* `clear();` //清空容器的所有数据
* `erase(beg,end);` //删除[beg,end)区间的数据，返回下一个数据的位置。
* `erase(pos);` //删除pos位置的数据，返回下一个数据的位置。


**示例：**

#include

void printDeque(const deque& d)
{
for (deque::const_iterator it = d.begin(); it != d.end(); it++) {
cout << *it << " ";

}
cout << endl;

}
//两端操作
void test01()
{
deque d;
//尾插
d.push_back(10);
d.push_back(20);
//头插
d.push_front(100);
d.push_front(200);

printDeque(d);

//尾删
d.pop_back();
//头删
d.pop_front();
printDeque(d);

}

//插入
void test02()
{
deque d;
d.push_back(10);
d.push_back(20);
d.push_front(100);
d.push_front(200);
printDeque(d);

d.insert(d.begin(), 1000);
printDeque(d);

d.insert(d.begin(), 2,10000);
printDeque(d);

deque<int>d2;
d2.push_back(1);
d2.push_back(2);
d2.push_back(3);

d.insert(d.begin(), d2.begin(), d2.end());
printDeque(d);

}

//删除
void test03()
{
deque d;
d.push_back(10);
d.push_back(20);
d.push_front(100);
d.push_front(200);
printDeque(d);

d.erase(d.begin());
printDeque(d);

d.erase(d.begin(), d.end());
d.clear();
printDeque(d);

}

int main() {

//test01();

//test02();

test03();

system("pause");

return 0;

}

总结：


* 插入和删除提供的位置是迭代器！
* 尾插 — push\_back
* 尾删 — pop\_back
* 头插 — push\_front
* 头删 — pop\_front


##### 1.2.6 deque 数据存取


**功能描述：**


* 对deque 中的数据的存取操作


**函数原型：**


* `at(int idx);` //返回索引idx所指的数据
* `operator[];` //返回索引idx所指的数据
* `front();` //返回容器中第一个数据元素
* `back();` //返回容器中最后一个数据元素


**示例：**

#include

void printDeque(const deque& d)
{
for (deque::const_iterator it = d.begin(); it != d.end(); it++) {
cout << *it << " ";

}
cout << endl;

}

//数据存取
void test01()
{

deque<int> d;
d.push_back(10);
d.push_back(20);
d.push_front(100);
d.push_front(200);

for (int i = 0; i < d.size(); i++) {
	cout << d[i] << " ";
}
cout << endl;


for (int i = 0; i < d.size(); i++) {
	cout << d.at(i) << " ";
}
cout << endl;

cout << "front:" << d.front() << endl;

cout << "back:" << d.back() << endl;

}

int main() {

test01();

system("pause");

return 0;

}

总结：


* 除了用迭代器获取deque容器中元素，[ ]和at也可以
* front返回容器第一个元素
* back返回容器最后一个元素


##### 1.2.7 deque 排序


**功能描述：**


* 利用算法实现对deque容器进行排序


**算法：**


* `sort(iterator beg, iterator end)` //对beg和end区间内元素进行排序


**示例：**

#include
#include

void printDeque(const deque& d)
{
for (deque::const_iterator it = d.begin(); it != d.end(); it++) {
cout << *it << " ";

}
cout << endl;

}

void test01()
{

deque<int> d;
d.push_back(10);
d.push_back(20);
d.push_front(100);
d.push_front(200);

printDeque(d);
sort(d.begin(), d.end());
printDeque(d);

}

int main() {

test01();

system("pause");

return 0;

}

#### 1.3 stack容器


##### 1.3.1 stack 基本概念


**概念：**stack是一种**先进后出**(First In Last Out,FILO)的数据结构，它只有一个出口


![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-k3AAY7zr-1630623757485)(assets/clip_image002-1547604555425.jpg)]](https://img-blog.csdnimg.cn/889c79b7ad3c453194261717181bb09a.jpg?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBARHJhZ29u5bCR5bm0,size_12,color_FFFFFF,t_70,g_se,x_16)


栈中只有顶端的元素才可以被外界使用，因此栈不允许有遍历行为


栈中进入数据称为 — **入栈** `push`


栈中弹出数据称为 — **出栈** `pop`


##### 1.3.2 stack 常用接口


功能描述：栈容器常用的对外接口


构造函数：


* `stack<T> stk;` //stack采用模板类实现， stack对象的默认构造形式
* `stack(const stack &stk);` //拷贝构造函数


赋值操作：


* `stack& operator=(const stack &stk);` //重载等号操作符


数据存取：


* `push(elem);` //向栈顶添加元素
* `pop();` //从栈顶移除第一个元素
* `top();` //返回栈顶元素


大小操作：


* `empty();` //判断堆栈是否为空
* `size();` //返回栈的大小


**示例：**

#include

//栈容器常用接口
void test01()
{
//创建栈容器 栈容器必须符合先进后出
stack s;

//向栈中添加元素，叫做 压栈 入栈
s.push(10);
s.push(20);
s.push(30);

while (!s.empty()) {
	//输出栈顶元素
	cout << "栈顶元素为： " << s.top() << endl;
	//弹出栈顶元素
	s.pop();
}
cout << "栈的大小为：" << s.size() << endl;

}

int main() {

test01();

system("pause");

return 0;

}

总结：


* 入栈 — push
* 出栈 — pop
* 返回栈顶 — top
* 判断栈是否为空 — empty
* 返回栈大小 — size


#### 1.4 queue 容器


##### 1.4.1 queue 基本概念


**概念：**Queue是一种**先进先出**(First In First Out,FIFO)的数据结构，它有两个出口


![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NLlnH6Av-1630623757497)(assets/clip_image002-1547606475892.jpg)]](https://img-blog.csdnimg.cn/a73ca1fde4d640e2a56e31ae38f09c65.jpg?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBARHJhZ29u5bCR5bm0,size_16,color_FFFFFF,t_70,g_se,x_16)


队列容器允许从一端新增元素，从另一端移除元素


队列中只有队头和队尾才可以被外界使用，因此队列不允许有遍历行为


队列中进数据称为 — **入队** `push`


队列中出数据称为 — **出队** `pop`


##### 1.4.2 queue 常用接口


功能描述：栈容器常用的对外接口


构造函数：


* `queue<T> que;` //queue采用模板类实现，queue对象的默认构造形式
* `queue(const queue &que);` //拷贝构造函数


赋值操作：


* `queue& operator=(const queue &que);` //重载等号操作符


数据存取：


* `push(elem);` //往队尾添加元素
* `pop();` //从队头移除第一个元素
* `back();` //返回最后一个元素
* `front();` //返回第一个元素


大小操作：


* `empty();` //判断堆栈是否为空
* `size();` //返回栈的大小


**示例：**

#include
#include
class Person
{
public:
Person(string name, int age)
{
this->m_Name = name;
this->m_Age = age;
}

string m_Name;
int m_Age;

};

void test01() {

//创建队列
queue<Person> q;

//准备数据
Person p1("唐僧", 30);
Person p2("孙悟空", 1000);
Person p3("猪八戒", 900);
Person p4("沙僧", 800);

//向队列中添加元素  入队操作
q.push(p1);
q.push(p2);
q.push(p3);
q.push(p4);

//队列不提供迭代器，更不支持随机访问	
while (!q.empty()) {
	//输出队头元素
	cout << "队头元素-- 姓名： " << q.front().m_Name 
          << " 年龄： "<< q.front().m_Age << endl;
    
	cout << "队尾元素-- 姓名： " << q.back().m_Name  
          << " 年龄： " << q.back().m_Age << endl;
    
	cout << endl;
	//弹出队头元素
	q.pop();
}

cout << "队列大小为：" << q.size() << endl;

}

int main() {

test01();

system("pause");

return 0;

}

总结：


* 入队 — push
* 出队 — pop
* 返回队头元素 — front
* 返回队尾元素 — back
* 判断队是否为空 — empty
* 返回队列大小 — size


#### 1.5 list容器


##### 1.5.1 list基本概念


\*\*功能：\*\*将数据进行链式存储


**链表**（list）是一种物理存储单元上非连续的存储结构，数据元素的逻辑顺序是通过链表中的指针链接实现的


链表的组成：链表由一系列**结点**组成


结点的组成：一个是存储数据元素的**数据域**，另一个是存储下一个结点地址的**指针域**


STL中的链表是一个双向循环链表


![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IGnLWsXo-1630623757504)(assets/clip_image002-1547608564071.jpg)]](https://img-blog.csdnimg.cn/1a39427cabfc4cc4a1278948c454ca07.jpg?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBARHJhZ29u5bCR5bm0,size_16,color_FFFFFF,t_70,g_se,x_16)


由于链表的存储方式并不是连续的内存空间，因此链表list中的迭代器只支持前移和后移，属于**双向迭代器**


list的优点：


* 采用动态存储分配，不会造成内存浪费和溢出
* 链表执行插入和删除操作十分方便，修改指针即可，不需要移动大量元素


list的缺点：


* 链表灵活，但是空间(指针域) 和 时间（遍历）额外耗费较大


List有一个重要的性质，插入操作和删除操作都不会造成原有list迭代器的失效，这在vector是不成立的。


总结：STL中**List和vector是两个最常被使用的容器**，各有优缺点


##### 1.5.2 list构造函数


**功能描述：**


* 创建list容器


**函数原型：**


* `list<T> lst;` //list采用采用模板类实现,对象的默认构造形式：
* `list(beg,end);` //构造函数将[beg, end)区间中的元素拷贝给本身。
* `list(n,elem);` //构造函数将n个elem拷贝给本身。
* `list(const list &lst);` //拷贝构造函数。


**示例：**

#include

void printList(const list& L) {

for (list<int>::const_iterator it = L.begin(); it != L.end(); it++) {
	cout << *it << " ";
}
cout << endl;

}

void test01()
{
listL1;
L1.push_back(10);
L1.push_back(20);
L1.push_back(30);
L1.push_back(40);

printList(L1);

list<int>L2(L1.begin(),L1.end());
printList(L2);

list<int>L3(L2);
printList(L3);

list<int>L4(10, 1000);
printList(L4);

}

int main() {

test01();

system("pause");

return 0;

}

##### 1.5.3 list 赋值和交换


**功能描述：**


* 给list容器进行赋值，以及交换list容器


**函数原型：**


* `assign(beg, end);` //将[beg, end)区间中的数据拷贝赋值给本身。
* `assign(n, elem);` //将n个elem拷贝赋值给本身。
* `list& operator=(const list &lst);` //重载等号操作符
* `swap(lst);` //将lst与本身的元素互换。


**示例：**

#include

void printList(const list& L) {

for (list<int>::const_iterator it = L.begin(); it != L.end(); it++) {
	cout << *it << " ";
}
cout << endl;

}

//赋值和交换
void test01()
{
listL1;
L1.push_back(10);
L1.push_back(20);
L1.push_back(30);
L1.push_back(40);
printList(L1);

//赋值
list<int>L2;
L2 = L1;
printList(L2);

list<int>L3;
L3.assign(L2.begin(), L2.end());
printList(L3);

list<int>L4;
L4.assign(10, 100);
printList(L4);

}

//交换
void test02()
{

list<int>L1;
L1.push_back(10);
L1.push_back(20);
L1.push_back(30);
L1.push_back(40);

list<int>L2;
L2.assign(10, 100);

cout << "交换前： " << endl;
printList(L1);
printList(L2);

cout << endl;

L1.swap(L2);

cout << "交换后： " << endl;
printList(L1);
printList(L2);

}

int main() {

//test01();

test02();

system("pause");

return 0;

}

##### 1.5.4 list 大小操作


**功能描述：**


* 对list容器的大小进行操作


**函数原型：**


* `size();` //返回容器中元素的个数
* `empty();` //判断容器是否为空
* `resize(num);` //重新指定容器的长度为num，若容器变长，则以默认值填充新位置。

 ​ //如果容器变短，则末尾超出容器长度的元素被删除。
* `resize(num, elem);` //重新指定容器的长度为num，若容器变长，则以elem值填充新位置。

 

			    //如果容器变短，则末尾超出容器长度的元素被删除。

**示例：**

#include

void printList(const list& L) {

for (list<int>::const_iterator it = L.begin(); it != L.end(); it++) {
	cout << *it << " ";
}
cout << endl;

}

//大小操作
void test01()
{
listL1;
L1.push_back(10);
L1.push_back(20);
L1.push_back(30);
L1.push_back(40);

if (L1.empty())
{
	cout << "L1为空" << endl;
}
else
{
	cout << "L1不为空" << endl;
	cout << "L1的大小为： " << L1.size() << endl;
}

//重新指定大小
L1.resize(10);
printList(L1);

L1.resize(2);
printList(L1);

}

int main() {

test01();

system("pause");

return 0;

}

总结：


* 判断是否为空 — empty
* 返回元素个数 — size
* 重新指定个数 — resize


##### 1.5.5 list 插入和删除


**功能描述：**


* 对list容器进行数据的插入和删除


**函数原型：**


* push\_back(elem);//在容器尾部加入一个元素
* pop\_back();//删除容器中最后一个元素
* push\_front(elem);//在容器开头插入一个元素
* pop\_front();//从容器开头移除第一个元素
* insert(pos,elem);//在pos位置插elem元素的拷贝，返回新数据的位置。
* insert(pos,n,elem);//在pos位置插入n个elem数据，无返回值。
* insert(pos,beg,end);//在pos位置插入[beg,end)区间的数据，无返回值。
* clear();//移除容器的所有数据
* erase(beg,end);//删除[beg,end)区间的数据，返回下一个数据的位置。
* erase(pos);//删除pos位置的数据，返回下一个数据的位置。
* remove(elem);//删除容器中所有与elem值匹配的元素。


**示例：**

#include

void printList(const list& L) {

for (list<int>::const_iterator it = L.begin(); it != L.end(); it++) {
	cout << *it << " ";
}
cout << endl;

}

//插入和删除
void test01()
{
list L;
//尾插
L.push_back(10);
L.push_back(20);
L.push_back(30);
//头插
L.push_front(100);
L.push_front(200);
L.push_front(300);

printList(L);

//尾删
L.pop_back();
printList(L);

//头删
L.pop_front();
printList(L);

//插入
list<int>::iterator it = L.begin();
L.insert(++it, 1000);
printList(L);

//删除
it = L.begin();
L.erase(++it);
printList(L);

//移除
L.push_back(10000);
L.push_back(10000);
L.push_back(10000);
printList(L);
L.remove(10000);
printList(L);

//清空
L.clear();
printList(L);

}

int main() {

test01();

system("pause");

return 0;

}

总结：


* 尾插 — push\_back
* 尾删 — pop\_back
* 头插 — push\_front
* 头删 — pop\_front
* 插入 — insert
* 删除 — erase
* 移除 — remove
* 清空 — clear


##### 1.5.6 list 数据存取


**功能描述：**


* 对list容器中数据进行存取


**函数原型：**


* `front();` //返回第一个元素。
* `back();` //返回最后一个元素。


**示例：**

#include

//数据存取
void test01()
{
listL1;
L1.push_back(10);
L1.push_back(20);
L1.push_back(30);
L1.push_back(40);

//cout << L1.at(0) << endl;//错误 不支持at访问数据
//cout << L1[0] << endl; //错误  不支持[]方式访问数据
cout << "第一个元素为： " << L1.front() << endl;
cout << "最后一个元素为： " << L1.back() << endl;

//list容器的迭代器是双向迭代器，不支持随机访问
list<int>::iterator it = L1.begin();
//it = it + 1;//错误，不可以跳跃访问，即使是+1

}

int main() {

test01();

system("pause");

return 0;

}

总结：


* list容器中不可以通过[]或者at方式访问数据
* 返回第一个元素 — front
* 返回最后一个元素 — back


##### 1.5.7 list 反转和排序


**功能描述：**


* 将容器中的元素反转，以及将容器中的数据进行排序


**函数原型：**


* `reverse();` //反转链表
* `sort();` //链表排序


**示例：**

void printList(const list& L) {

for (list<int>::const_iterator it = L.begin(); it != L.end(); it++) {
	cout << *it << " ";
}
cout << endl;

}

bool myCompare(int val1 , int val2)
{
return val1 > val2;
}

//反转和排序
void test01()
{
list L;
L.push_back(90);
L.push_back(30);
L.push_back(20);
L.push_back(70);
printList(L);

//反转容器的元素
L.reverse();
printList(L);

//排序
L.sort(); //默认的排序规则 从小到大
printList(L);

L.sort(myCompare); //指定规则，从大到小
printList(L);

}

int main() {

test01();

system("pause");

return 0;

}

总结：


* 反转 — reverse
* 排序 — sort （成员函数）


##### 1.5.8 排序案例


案例描述：将Person自定义数据类型进行排序，Person中属性有姓名、年龄、身高


排序规则：按照年龄进行升序，如果年龄相同按照身高进行降序


**示例：**

#include
#include
class Person {
public:
Person(string name, int age , int height) {
m_Name = name;
m_Age = age;
m_Height = height;
}

public:
string m_Name; //姓名
int m_Age; //年龄
int m_Height; //身高
};

bool ComparePerson(Person& p1, Person& p2) {

if (p1.m_Age == p2.m_Age) {
	return p1.m_Height  > p2.m_Height;
}
else
{
	return  p1.m_Age < p2.m_Age;
}

}

void test01() {

list<Person> L;

Person p1("刘备", 35 , 175);
Person p2("曹操", 45 , 180);
Person p3("孙权", 40 , 170);
Person p4("赵云", 25 , 190);
Person p5("张飞", 35 , 160);
Person p6("关羽", 35 , 200);

L.push_back(p1);
L.push_back(p2);
L.push_back(p3);
L.push_back(p4);
L.push_back(p5);
L.push_back(p6);

for (list<Person>::iterator it = L.begin(); it != L.end(); it++) {
	cout << "姓名： " << it->m_Name << " 年龄： " << it->m_Age 
          << " 身高： " << it->m_Height << endl;
}

cout << "---------------------------------" << endl;
L.sort(ComparePerson); //排序

for (list<Person>::iterator it = L.begin(); it != L.end(); it++) {
	cout << "姓名： " << it->m_Name << " 年龄： " << it->m_Age 
          << " 身高： " << it->m_Height << endl;
}

}

int main() {

test01();

system("pause");

return 0;

}

* 对于自定义数据类型，必须要指定排序规则，否则编译器不知道如何进行排序
* 高级排序只是在排序规则上再进行一次逻辑规则制定，并不复杂


#### 1.6 set/ multiset 容器


##### 1.6.1 set基本概念


**简介：**


* 所有元素都会在插入时自动被排序


**本质：**


* set/multiset属于**关联式容器**，底层结构是用**二叉树**实现。


**set和multiset区别**：


* set不允许容器中有重复的元素
* multiset允许容器中有重复的元素


##### 1.6.2 set构造和赋值


功能描述：创建set容器以及赋值


构造：


* `set<T> st;` //默认构造函数：
* `set(const set &st);` //拷贝构造函数


赋值：


* `set& operator=(const set &st);` //重载等号操作符


**示例：**

#include

void printSet(set & s)
{
for (set::iterator it = s.begin(); it != s.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}

//构造和赋值
void test01()
{
set s1;

s1.insert(10);
s1.insert(30);
s1.insert(20);
s1.insert(40);
printSet(s1);

//拷贝构造
set<int>s2(s1);
printSet(s2);

//赋值
set<int>s3;
s3 = s2;
printSet(s3);

}

int main() {

test01();

system("pause");

return 0;

}

* set容器插入数据时用insert
* set容器插入数据的数据会自动排序


##### 1.6.3 set大小和交换


**功能描述：**


* 统计set容器大小以及交换set容器


**函数原型：**


* `size();` //返回容器中元素的数目
* `empty();` //判断容器是否为空
* `swap(st);` //交换两个集合容器


**示例：**

#include

void printSet(set & s)
{
for (set::iterator it = s.begin(); it != s.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}

//大小
void test01()
{

set<int> s1;

s1.insert(10);
s1.insert(30);
s1.insert(20);
s1.insert(40);

if (s1.empty())
{
	cout << "s1为空" << endl;
}
else
{
	cout << "s1不为空" << endl;
	cout << "s1的大小为： " << s1.size() << endl;
}

}

//交换
void test02()
{
set s1;

s1.insert(10);
s1.insert(30);
s1.insert(20);
s1.insert(40);

set<int> s2;

s2.insert(100);
s2.insert(300);
s2.insert(200);
s2.insert(400);

最后

Python崛起并且风靡，因为优点多、应用领域广、被大牛们认可。学习 Python 门槛很低，但它的晋级路线很多，通过它你能进入机器学习、数据挖掘、大数据，CS等更加高级的领域。Python可以做网络应用，可以做科学计算，数据分析，可以做网络爬虫，可以做机器学习、自然语言处理、可以写游戏、可以做桌面应用…Python可以做的很多，你需要学好基础，再选择明确的方向。这里给大家分享一份全套的 Python 学习资料，给那些想学习 Python 的小伙伴们一点帮助！

👉Python所有方向的学习路线👈

Python所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。

👉Python必备开发工具👈

工欲善其事必先利其器。学习Python常用的开发软件都在这里了，给大家节省了很多时间。

👉Python全套学习视频👈

我们在看视频学习的时候，不能光动眼动脑不动手，比较科学的学习方法是在理解之后运用它们，这时候练手项目就很适合了。

👉实战案例👈

学python就与学数学一样，是不能只看书不做题的，直接看步骤和答案会让人误以为自己全都掌握了，但是碰到生题的时候还是会一筹莫展。

因此在学习python的过程中一定要记得多动手写代码，教程只需要看一两遍即可。

👉大厂面试真题👈

我们学习Python必然是为了找到高薪的工作，下面这些面试题是来自阿里、腾讯、字节等一线互联网大厂最新的面试资料，并且有阿里大佬给出了权威的解答，刷完这一套面试资料相信大家都能找到满意的工作。

需要这份系统化学习资料的朋友，可以戳这里无偿获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！