学习视频：黑马程序员匠心之作|C++教程从0到1入门编程,学习编程不再难 因为可能会因为不同容器而有不同的头文件，为了方便我们直接使用万能头文件：
#include <bits/stdc++.h>
常用容器总结与对比： ==因为有些代码过长，表格无法完全表示，我用名字来代替，可以在下面找到相应的代码。例如：vector_1，可以在下方找到vector的构造函数。==
| 容器名称 | vector | deque | stack | queue |
|---|---|---|---|---|
| 底层数据结构 | 单端数组 | 双端数组 | 栈 | 队列 |
| 构造函数 | vector_1 | deque_1 | stack_1 | queue_1 |
| 是否允许遍历 | 是 | 是 | 否 | 否 |
| 赋值操作 | vector_2 | deque_2 | stack_2 | queue_2 |
| 存储操作 | push_back(ele);//插入ele数据 pop_back();//删除最后一个数据 | push_back(elem); //在尾部添加一个数据 push_front(elem); //在头部插入一个数据 pop_back();//删除容器最后一个数据 pop_front(); //删除容器第一个数据 | push(elem); //栈顶添加元素 pop();//从栈顶移除第一个元素 top();//返回栈顶元素 | push(elem);//往队尾添加元素 pop();//从队头移除第一个元素 back();//返回最后一个元素 front(); //返回第一个元素 |
| 大小操作 | vector_3 因为vector容量可 动态扩展，所以还有个容量知识点 | deque_3 | stack_3 | queue_3 |
| 插入和删除 | vector_4 | deque_4 | 无 | 无 |
| 元素的获取 | []或者at方法 | []或者at方法 | 无 | 无 |
| 容器内部其他算法 | vector< int>v1; vector< int> v2; //容器交换 v1.swap(v2); | deque< int> d1; deque< int> d2; //容器交换 d1.swap(d2); | stack s1; stack s2; //容器交换 s1.swap(s2); | deque d1; deque d2; //容器交换 d1.swap(d2); |
| c++的标准算法:sort,for_each,find等是否可以使用 | 可以 | 可以 | 可以 | 可以 |
| 容器名称 | list | set | map |
|---|---|---|---|
| 底层数据结构 | 链表 | 二叉树自动排序而且去除重复元素 | 二叉树 所有元素都是 pair型(键值对)不允许用重复的key元素 |
| 构造函数 | list_1 | set_1 | map_1 |
| 是否允许遍历 | 是 | 是 | 是 |
| 赋值操作 | list_2 | set_2 | map_2 |
| 存储操作 | push_back(ele);//插入ele数据 pop_back();//删除最后一个数据 | insert(ele);插入ele数据 | insert(pair<int, int>(1, 10));插入键值对1:10 |
| 大小操作 | list_3 | set_3 | map_3 |
| 插入和删除 | list_4 | insert(ele);插入ele元素 erase(ele);删除ele元素 | map_4 |
| 元素的获取 | 通过遍历获取 | 通过遍历获取 | 通过遍历获取 |
| 容器内部其他算法 | list_5 | set_4 | map_5 |
| c++的标准算法:sort,for_each,find等是否可以使用 | 不能 | 不能 | 不能 |
1.vector容器
vector_1：vector构造函数：
vector<int> v1; //无参构造;
vector<int> v2(v1.begin(), v1.end());//区间拷贝构造函数;
vector<int> v3(v2);//拷贝构造函数
vector_2:赋值操作
//直接赋值操作
vector<int> v1; //无参构造
vector<int>v2;
v2 = v1;
//区间拷贝赋值，这种方法使用比较少。
vector<int>v3;
v3.assign(v1.begin(), v1.end());
vector_3:vector的大小与容量操作
vector<int> v1;
//判断容器是否为空
v1.empty();
//容器的容量
v1.capacity();
//容器元素个数
v1.size();
//重新指定容器大小
v1.resize(2);
vector_4:vector的删除与插入操作
//迭代器指向位置v1.begin()前插入元素100
vector<int> v1;
v1.insert(v1.begin(), 100);
//迭代器指向位置v1.begin()前插入2个元素1000
v1.insert(v1.begin(), 2, 1000);
//删除v1.begin()处的数据
v1.erase(v1.begin());
//删除v1.begin()到v1.begin()+1的元素
v1.erase(v1.begin(),v1.begin()+2);
//清空
v1.clear();
2.deque容器
deque_1:deque的构造函数
deque<int> d1; //无参构造函数
deque<int> d2(d1.begin(), d1.end());//区间拷贝构造函数;
deque<int> d3(d2);//拷贝构造函数
deque_2:赋值操作
//直接赋值操作
deque<int> d1; //无参构造
deque<int>d2;
d2 = d1;
//区间拷贝赋值，这种方法使用比较少。
deque<int>d3;
d3.assign(d1.begin(), d1.end());
deque_3:大小操作
deque<int> d1;
//判断容器是否为空
d1.empty();
//容器元素个数
d1.size();
//重新指定容器大小
d1.resize(2);
deque_4:deque的删除与插入操作
//在d1.begin()前位置插入一个1000
deque<int> d1
d1.insert(d1.begin(),1000);
//在d1.begin()位置插入2个100数据，无返回值。
d1.insert(d1.begin(),2,100);
//清空
d1.clear();
//删除[begin,end)区间的数据。
d1.erase(d1.begin(),d1.end());
/删除d1.begin()位置的数据，返回下一个数据的位置。
d1.erase(d1.begin());
3.stack容器
stack_1:stack的构造函数
因为stack栈中只有顶端的元素才可以被外界使用，因此栈不允许有遍历行为，begin和end方法都不能使用，所有没有区间拷贝构造函数。
stack<int> s1; //无参构造函数
stack<int> s2(s1); //拷贝构造函数
stack_2:赋值操作
//直接赋值操作，无拷贝赋值操作
stack<int> s1;
stack<int> s2;
s2=s1;
stack_3:大小操作
//判断s1是否为空
stack<int> s1;
s1.empty();
//判断s1的元素个数
s1.size();
4.queue容器
queue_1:queue的构造函数
因为queue队列中只有队头和队尾才可以被外界使用，因此队列不允许有遍历行为，begin和end方法都不能使用，所有没有区间拷贝构造函数。
queue<int> q1; //无参构造函数
queue<int> q2(q1); //拷贝构造函数
queue_2:赋值操作
//直接赋值操作
queue<int> q1; //无参构造
queue<int> q2;
q2 = q1;
queue_3:大小操作
//判断是否为空
queue<int> q1;
q1.empty();
//判断元素个数
q1.size();
5.list容器
list_1:list的构造函数
//无参构造
list<int> l1;
//区间拷贝构造函数
list<int> l2(l1.begin(),l1.end());
//拷贝构造函数
list<int> l3(l2);
list_2:赋值操作
//直接赋值操作
list<int> l1; //无参构造
list<int> l2;
l2 = l1;
//区间拷贝赋值，这种方法使用比较少。
list<int> l3;
l3.assign(l1.begin(), l1.end());
list_3:大小操作
list<int>L1;
//判断容器是否为空
L1.empty()；
//判断元素个数
L1.size();
//重新指定大小
L1.resize(10);
list_4:插入与删除
list<int> L;
//头删
L.pop_front();
//插入
list<int>::iterator it = L.begin();
L.insert(++it, 1000);
//删除
it = L.begin();
L.erase(++it);
//删除容器中所有的1000
L.remove(10000);
//清空
L.clear();
list_5:list内部的其他算法
list<int> l1;
list<int> l2;
//容器交换
l1.swap(l2);
//容器反转
l1.reverse();
//容器从小到大排序
l1.sort();
//容器从大到小排序
bool myCompare(int v1,int v2){
return v1>v2;
}
l1.sort(myCompare);
6.set容器
set_1:set的构造函数
//无参构造
set<int> s1;
//拷贝构造函数
set<int>s2(s1);
set_2:set赋值操作
set<int> s1;
set<int>s3;
s3 = s1;
set_3:大小操作
set<int> s1;
//容器是否为空
s1.empty();
//容器元素大小
s1.size();
//清空
s1.clear();
set_4：容器内部其他算法
set<int> s1;
set<int> s2;
//容器交换
s1.swap(s2);
//通过容器中元素3的个数
int num=s1.cout(3);
//查找容器中是否有元素30
set<int>::iterator pos = s1.find(30);
if (pos != s1.end())
{
cout << "找到了元素 ： " << *pos << endl;
}
else
{
cout << "未找到元素" << endl;
}
7.map容器
map_1：map的构造函数
//默认构造函数
map<int,int> m;
////拷贝构造
map<int, int> m2(m);
map_2: 赋值操作
map<int> m1;
map<int> m3;
m3 = m1;
map_3:大小操作
map<int,int> m;
//容器是否为空
map.empty();
//容器元素多少
m.size();
//清空
m.clear();
map_4:插入与删除
map<int, int> m;
//第一种插入方式
m.insert(pair<int, int>(1, 10));
//第二种插入方式
m.insert(make_pair(2, 20));
//第三种插入方式
m.insert(map<int, int>::value_type(3, 30));
//第四种插入方式，不建议使用
m[4] = 40;
//删除第一个元素
m.erase(m.begin());
//删除容器中的3
m.erase(3);
map_5:容器内部其他算法
map<int, int>m;
map<int, int>m1;
//容器交换
m.swap(m1);
//查找
map<int, int>::iterator pos = m.find(3);
if (pos != m.end())
{
cout << "找到了元素 key = " << (*pos).first << " value = " << (*pos).second << endl;
}
else
{
cout << "未找到元素" << endl;
}
//统计
int num = m.count(3);
