（知识点）C++算法竞赛语法基础：STL容器

---

目录

1、变长数组 #include

1.1 vector的定义

1.2 size/empty/clear函数

1.3迭代器 

1.4遍历

1.5 front/back函数

1.6 push_back()和pop_back()

1.7知识拓展：vector的倍增

2.队列 #include

2.1定义

2.2循环队列queue、优先队列priority_queue

 3 栈 #include

 4.双端队列 #include

5.#include

5.1 size/empty/clear

5.2迭代器

5.3 begin/end

5.4 insert

5.5 find

5.6 lower_bound/upper_bound

5.7 erase

5.8 count

6.#include

6.1声明

6.2 size/empty/clear/begin/end

6.3 insert/erase

6.4 find

6.5 []操作符

7.补充知识：#include、#include、#include、pair

---

1、变长数组 #include <vector>

vector其实是一个可以自动改变长度的数组，举例：假设一个数组个数为10万，数组的长度相当于10万，但是这整个数组的总长度小于等于100万。用普通的数组来表示：int q[100000][100000]（第一维10万，第二维10万），这样就相当于开了一个10的10次方的int，内存会炸了！！大约需要40G的空间。这种时候就要用vector，用多少就开多少，只需开10万个vector，每个vector用多少开多少，这样就可以保证开的总数组是10万级别的，即使多开一些也是常数倍大小。

1.1 vector的定义

#include <vector>   // 头文件
vector<int> a;      // 相当于一个长度动态变化的int数组
vector<int> b[233]; // 相当于第一维长233（静态），第二位长度动态变化的int数组（动态）
struct rec{…};
vector<rec> c;      // 自定义的结构体类型也可以保存在vector中

1.2 size/empty/clear函数

size函数返回vector的实际长度（包含的元素个数），empty函数返回一个bool类型，表明vector是否为空。二者的时间复杂度都是 O(1)。所有的STL容器都支持这两个方法，含义也相同，之后我们就不再重复给出。

clear函数把vector清空。

#include <vector>   // 头文件
#include<iostream>
using namespace std;
int main()
{
    vector<int> a; 
    a.size();//算数组长度
    a.empty();//返回bool变量，false为不空，true为空。
    a.clear();//将数组清空。
    return 0;
}

1.3迭代器 

迭代器就像STL容器的“指针”，可以用星号*操作符解除引用。vector的迭代器是“随机访问迭代器”，可以把vector的迭代器与一个整数相加减，其行为和指针的移动类似。可以把vector的两个迭代器相减，其结果也和指针相减类似，得到两个迭代器对应下标之间的距离。

一个保存int的vector的迭代器声明方法为：

int main()
{
	vector<int> a;
	vector<int>::iterator it = a.begin();//it访问的就是a[0]
	//it+2访问的就是a[2]
	// a.begin()就是第一个元素的地址，a.end()是最后一个元素的下一个位置，所以容器基本上都是左闭右开
	//取值就是*it 所以可以把迭代器当成指针来看。
	return 0;
}

1.4遍历

 下面有3种遍历方法：

int main()
{
	vector<int> a({ 1,2,3 });
	//法一
	for (int i = 0; i < a.size(); i++)
	{
		cout << a[i] << ' ';
	}
	cout << endl;
	//法二 用迭代器遍历 因为begin的类型已知为vector<int>::iterator,所以简写auto
	for (auto i = a.begin(); i != a.end(); i++)
	{
		cout << *i << ' ';
	}
	cout << endl;
	//法三 与string类似
	for (int x : a) cout << x << ' ';
	cout << endl;

	return 0;
}

结果：

1 2 3

1 2 3

1 2 3

（绝大部分的时候不会用迭代器遍历，哈哈哈，y总说太麻烦了）

1.5 front/back函数

front函数返回vector的第一个元素，等价于*a.begin()和a[0]。
back函数返回vector的最后一个元素，等价于*--a.end()和a[a.size() – 1]。

1.6 push_back()和pop_back()

a.push_back(x)把元素x插入到vector a的尾部。
b.pop_back()删除vector a的最后一个元素。

int main()
{
	vector<int> a({ 1,2,3 });
	cout << a.front() << endl;
	cout << a.back() << endl;
	a.push_back(4);
	for (int i = 0; i < a.size(); i++)
	{
		cout << a[i] << ' ';
	}
	cout << endl;
	a.pop_back();
	for (int i = 0; i < a.size(); i++)
	{
		cout << a[i] << ' ';
	}
	cout << endl;
	

	return 0;
}

运行结果：

1.7知识拓展：vector的倍增

2.队列 #include<queue>

2.1定义

int main()
{
	queue<int> q;//队列
	priority_queue<int> a;//大根堆 优先弹最大数
	priority_queue<int, vector<int>, greater<int>> b;//小根堆 优先弹最小数
	priority_queue<pair<int,int>> p;//二元组

	//如果想要自己定义一个结构体类型的优先队列，大根堆在结构体里一定要重载一个<，小根堆要>
	struct Rec
	{
		int a, b;
		//重载：
		bool operator<(const Rec& t) const
		{
			return a < t.a;
		}
	};
	priority_queue<Rec> d;
	d.push({ 1,2 });

	struct rec
	{
		int e, f;
		bool operator>(const rec& l)const
		{
			return l.e > e;
		}
	};
	priority_queue<rec,vector<rec>,greater<rec>> g;
	g.push({ 3,5 });

	return 0;
}

2.2循环队列queue、优先队列priority_queue

尾进头出，跟现实排队一样。

push    // 从队尾插入
pop     // 从队头弹出
front   // 返回队头元素
back    // 返回队尾元素

push    // 把元素插入堆
pop     // 删除堆顶元素
top     // 查询堆顶元素（最大值）

普通队列，优先队列，栈，是没有clear函数来清空的，若要清空，就重新初始化一下

int main()
{
	queue<int> q;//队列

	q.push(1);//在队尾插入一个数
	q.pop();//从队头弹出
	//普通队列只能从队尾插入，队头弹出，和现实生活中排队一样
	q.front();//返回队头
	cout << q.back() << endl;//返回队尾

	priority_queue<int> a;//大根堆 优先弹最大数

	a.push(1);//插入一个数 这时就不一定队尾插入了
	a.pop();//删除最大数 这时也不一定从队头弹出
	a.top();//取最大值

	
	//队列，优先队列，栈，是没有clear函数来清空的，若要清空，就重新初始化一下：
	q = queue<int>();

    return 0;
}

 3 栈 #include<stack>

#include <stack>
头文件stack包含栈。声明和前面的容器类似。栈顶进栈顶出

int main()
{
	stack<int> stk;
	stk.push(1);//从栈顶进
	stk.pop();//从栈顶出
	stk.top();//取栈顶元素

	return 0;
}

 4.双端队列 #include<deque>

双端队列deque是一个支持在两端高效插入或删除元素的连续线性存储空间。它就像是vector和queue的结合。与vector相比，deque在头部增删元素仅需要 O(1)的时间；与queue相比，deque像数组一样支持随机访问。

平均效率比vector和栈慢挺多，但常数比vector多一些。

[]              // 随机访问
begin/end       // 返回deque的头/尾迭代器
front/back      // 队头/队尾元素
push_back       // 从队尾入队
push_front      // 从队头入队
pop_back        // 从队尾出队
pop_front       // 从队头出队
clear           // 清空队列
 

#include<deque>

int main()
{
	deque<int> a;
	a.begin(), a.end();
	a.front(), a.back();

	a.push_back(1), a.push_front(2);
	a.pop_back(), a.pop_front();
	a[0];
	
	a.clear();

	return 0;
}

5.#include<set>

头文件set主要包括set和multiset两个容器，分别是“有序集合”和“有序多重集合”，即前者的元素不能重复，而后者可以包含若干个相等的元素。set和multiset的内部实现是一棵红黑树，它们支持的函数基本相同。 所有函数代码在下面。

5.1 size/empty/clear

与vector类似

5.2迭代器

set和multiset的迭代器称为“双向访问迭代器”，不支持“随机访问”，支持星号*解除引用，仅支持++和--两个与算术相关的操作。

设it是一个迭代器，例如set<int>::iterator it;

若把it ++，则it会指向“下一个”元素。这里的“下一个”元素是指在元素从小到大排序的结果中，排在it下一名的元素。同理，若把it --，则it将会指向排在“上一个”的元素。

5.3 begin/end

返回集合的首、尾迭代器，时间复杂度均为 O(1)

s.begin()是指向集合中最小元素的迭代器。

s.end()是指向集合中最大元素的下一个位置的迭代器。换言之，就像vector一样，是一个“前闭后开”的形式。因此-- s.end()是指向集合中最大元素的迭代器。

5.4 insert

s.insert(x)把一个元素x插入到集合s中，时间复杂度为 O(logn)。

在set中，若元素已存在，则不会重复插入该元素，对集合的状态无影响。

5.5 find

s.find(x)在集合s中查找等于x的元素，并返回指向该元素的迭代器。若不存在，则返回s.end()。时间复杂度为 O(logn)。

5.6 lower_bound/upper_bound

这两个函数的用法与find类似，但查找的条件略有不同，时间复杂度为 O(logn)。

s.lower_bound(x)查找大于等于x的元素中最小的一个，并返回指向该元素的迭代器。

s.upper_bound(x)查找大于x的元素中最小的一个，并返回指向该元素的迭代器。

5.7 erase

设it是一个迭代器，s.erase(it)从s中删除迭代器it指向的元素，时间复杂度为 O(logn)。

设x是一个元素，s.erase(x)从s中删除所有等于x的元素，时间复杂度为 O(k+logn)。
，其中 k是被删除的元素个数。

5.8 count

s.count(x)返回集合s中等于x的元素个数，时间复杂度为 O(k+logn)。
，其中 k为元素x的个数。

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

int main()
{
	set<int> a;//元素不能重复，如果有重复则这个操作会忽视掉
	multiset<int> b;

	set<int>::iterator it = a.begin();//指向集合中最小的迭代器
	a.end();//指向元素最大的下一个迭代器
	//存在 it++; ++it;
	//存在 it--; --it;

	a.insert(1);//插入一个元素，在set中若1存在则不会重复插入
	a.find(0);//找等于0的元素，返回迭代器，若不存在，则返回a.end();
	if (a.find(0) == a.end());//判断0是否在a中存在，但不常用。

	a.lower_bound(0);//找到>=0的最小的元素的迭代器
	a.upper_bound(0);//找到>=0的最大的元素的迭代器

	b.count(0);//返回b中=0的元素个数
	a.count(0);//因为set中没有重复元素，所以有0这个元素则返回1，没有则返回0.

	a.erase(0);//删除等于0的元素
	a.erase(it);//删除迭代器it指向的元素

	//自己定义一个结构体,也是要有小于号 <（跟大根堆类似）
	struct Rec
	{
		int x, y;
		bool operator<(const Rec& t)const
		{
			return t.x < x;
		}
	};
	set<Rec> c;

	return 0;
}

6.#include<map>

map容器是一个键值对key-value的映射，其内部实现是一棵以key为关键码的红黑树。Map的key和value可以是任意类型，其中key必须定义小于号运算符。

6.1声明

map<key_type, value_type> name;

//例如：
map<long long, bool> vis;
map<string, int> hash;
map<pair<int, int>, vector<int>> test;

6.2 size/empty/clear/begin/end

均与set类似。

6.3 insert/erase

与set类似，但其参数均是pair<key_type, value_type>。

6.4 find

h.find(x)在变量名为h的map中查找key为x的二元组。

6.5 []操作符

h[key]返回key映射的value的引用，时间复杂度为 O(logn)。

[]操作符是map最吸引人的地方。我们可以很方便地通过h[key]来得到key对应的value，还可以对h[key]进行赋值操作，改变key对应的value。

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

int main()
{
	map<string, int> a;//映射，二元组，第一个元素用到第二个元素
	a["yxc"] = 2;
	cout << a["yxc"] << endl;

	map<string, vector<int>> b;
	b["yxc"] = vector<int>();
	cout << b["yxc"].size() << endl;
	b["yxc"] = vector<int>({1,2,3,4});
	cout << b["yxc"][2] << endl;

	b.insert({ "a",{}});//插入

	//查找
	cout << (a.find({ "yxc",{} }) == a.end()) << endl;
	cout << (a.find({ "yxc",(1,2,3,4)}) == a.end()) << endl;
	cout << (a.find({ "yxc","1,2,3,4"}) == a.end()) << endl;

	return 0;
}

运行结果：

7.补充知识：#include<unordered_set>、#include<unordered_map>、#include<bitset>、pair

#include<unordered_set>//与set类似，但其是无序的，底层逻辑是哈希表
#include<unordered_map>//同理
#include<bitset>//位运算用 无clear函数
#include<iostream>
using namespace std;

int main()
{
	unordered_set<int> a;//哈希表 与set用法基本一样，因为无序 所以不能二分 但效率高O(1)
	unordered_multiset<int> b;

	unordered_map<int, int> c;//相较map更常用这个
	unordered_multimap<int, int> d;

	bitset<1000> e;//中括号里是长度 是一个0/1组成的串
	e[0] = 1;
	cout << e[2] << endl;//未赋值默认0
	e[1] = 1;
	cout << e.count() << endl;//长度
	e.set(3);//把第3个位置设成1
	cout << e[3] << endl;
	e.reset(3);//把第3个位置设成0
	cout << e[3] << endl;

	pair<int, string> g;
	g = { 3,"yxc" };
	cout << g.first << ' ' << g.second << endl;
    g = make_pair(4, "abc");//在C++结构里不能直接赋值，要用到make_pair函数
	//pair的好处在于能比较运算，是双关键字比较，先比较第一个，类似字典序比较。

	//vector也有这种比较,字典序顺序
	vector<int> m, n;
	//if(m == n) == != < > <= >=

	return 0;
}

运行结果：