C++ 容器

参考网站

@点击跳转

vector动态数组

特点：可变数组（动态数组），可在末端快速插入、删除，可随机访问任何元素。

实现动态增长原理：
数组满了后，再往里面添加元素，cpu会申请更大空间，把原数组数据copy到新空间中，再把新元素插入进去；

1. 首先：

   #include <vector>
   

2. 创建和初始化

   vector<T> vec;
   vector<T> vec(size); //创建具有size个元素的vector
   vector<T> vec(size, val); //创建具有size个元素的vector,初始值为val
   

3. 获取迭代器

   vector<int> v1;
   vector<int>::iterator it1 = v1.begin();
   vector<int>::iterator it2 = v1.end();
   
   vec.begin()、 vec.end()、 vec.rbegin()、 vec.rend() //后两个为逆迭代器
   

   

4. 常用操作函数

   vec.at(n) 	//返回vec中位置为n的元素
   vec[n]
       
   vec.back() 	//返回vec中最后一个元素
   vec.front() //返回vec中的第一个元素
   
   vec.push_back(a) //将元素a插入到vec的末尾
   vec.pop_back() //删除vec中的末尾元素
   
   vec.clear() //清除vec中的所有元素
   vec.empty() //判断vec是否为空，为空返回true，否则返回false
       
   vec.begin()、 vec.end()、 vec.rbegin()、 vec.rend() //后两个为逆迭代器
   vec.size() //返回vec中的元素数量
   
   vec.resize(int num);  //重新设置大小，若比原来小，多余的被抛弃，若比原来大，用0填充多出的
   vec.resize(int , 4);  //重新设置大小，若比原来大，用4填充多出的
   
   vec.insert(v.begin(), 30); //表示插入操作完成后30位于v.begin()的位置
   
   vec.erase(v.begin());  //删除v.begin()位置的元素
   vec.erase(v.begin()+1, v.end());  //删除第2个之后的元素
   

stack栈

特点：只允许读写栈顶元素，不支持访问除栈顶元素外的任意元素，没有迭代器

1. 创建

   #include <stack>
   stack<T> sta;
   

2. 基本操作：

   sta.top() //返回sta的栈顶元素
   sta.pop() //删除sta的栈顶元素
   sta.push(a) //向sta的栈顶插入元素a
   
   sta.empty() //检查sta是否为空
   sta.size() //返回容纳的元素数量
   

queue队列

特点：只能访问首尾元素（队头：移出元素，获取元素； 队尾：插入、获取），没有迭代器

1. 创建

#include <queue>
queue<T> que;

2. 基本操作

 que.front() 	//返回que的队头元素
 que.back() 		//返回que的队尾元素
     
 que.push(a) 	//向que的尾部插入元素a
 que.pop() 		//删除que的队头元素
     
 que.empty() 	//检查que是否为空
 que.size() 		//返回que容纳的元素数量

priority_queue优先队列（堆）

特点：最大元素查找时间复杂度O(1)，插入与释出O(log(n))

1. 创建（默认会创建一个最大堆）

   #include <queue>
   priority_queue<int> q;   // 创建最大堆
   priority_queue<int, vector<int>, greater<int> > q2;  //最小堆， vector为底层容器
   

2. 基本操作

   //元素访问
   top();     //栈顶元素
   
   //容量
   empty();
   size();
   
   //修改器
   push(a);  //插入元素，并对底层容器排序
   pop();	//删除队首元素
   swap();
   
   

set集合

有序、不可重复集合set

特点：查、插、删、改的时间复杂度均为O(logn)

1. 创建：

   set<T> st;   			// 默认升序
   set<T, greater<T>> st; 	//降序
   

2. 基本操作

   st.begin() st.end() st.rbegin() st.rend(); //返回迭代器
   
   st.insert(a); //往st中插入元素a
   
   st.erase(iterator it); //删除st中it指向的元素
   st.erase(iterator itl, iterator itr); //删除st中[itl,itr)之间的元素
   st.erase(a); //删除st中值为a的元素
   
   st.clear(); //清除st中所有元素
   
   st.count(a); //返回st中值为a的元素数量（1或0）
   st.find(a); //返回st中指向值为a的元素的迭代器，若找不到返回st.end()
   
   st.lower_bound(a); //返回指向首个值不小于a的元素的迭代器
   st.upper_bound(a); //返回指向首个值大于a的元素的迭代器
   
   

有序、可重复集合multiset

特点：查、插、删、改的时间复杂度均为O(logn)

1. 创建

   #include <set>
   multiset<T> st;
   multiset<T, greater<T>> st; //降序
   

2. 常用操作与set相同，个别有微小区别

   find(a)   //返回指向“第一个”a的迭代器
   

无序集合unordered_set、unordered_multiset

特点：查、插、删的时间复杂度均为O(1)

1. 创建

   #include <unordered_set>   //注意与上面2个不同
   unordered_set<T> st; 
   unordered_multiset<T> st;
   

2. 基本操作与set/multiset基本相同，但不支持修改

map

map有序

特点：

• 按照键值队排序的集合，

• 查、插、删、改的时间复杂度均为O(logn)

1. 创建与初始化(例如)

   #include <map>
   map<string, int> mp = {{"A", 1}, {"B", 2}};
   mp["C"] = 3;
   

   

2. 基本操作

   mp.begin();   mp.end();   mp.rbegin();   mp.rend();
   
   mp[a];  // 读写键为a的元素
   
   mp.empty();  // 检查mp是否为空
   mp.size();  // 返回mp容纳的元素数
   mp.clear();  // 清除mp的所有元素
   
   mp.erase(iterator it);  // 移除mp中it指向的元素
   mp.erase(a);  // 移除mp中键为a的元素
   

unordered_map 无序

特点：使用哈希算法，时间复杂度O(1)

1. 创建（与map相同）

2. 基本操作

   //迭代器
   begin() end()  
   
   //容量
   empty();
   size();       //返回容纳的元素数
   max_size();		//返回可容纳的最大元素数c
       
   //查找
   at()   //访问指定的元素，同时进行越界检查
   operator[]  //访问或插入指定的元素
   count()			//返回匹配特定键的元素数量
   find()		//寻找带有特定键的元素
   contains()   //检查容器是否含有带特定键的元素
   equal_range()   //返回匹配特定键的元素范围
   
   //修改器
   clear()
   insert()   //插入元素或结点 (C++17 起)
   insert_or_assign()  //插入元素，或若键已存在则赋值给当前元素
   erase();
   swap();   //交换内容
   extract();	//从另一容器释出结点
   merge();		//从另一容器接合结点
   

   insert()

   unordered_map<int, string> dict = {{1, "one"}, {2, "two"}};
   dict.insert({3, "three"});
   dict.insert(std::make_pair(4, "four"));
   dict.insert({{4, "another four"}, {5, "five"}});