STL(常用)

STL

• 简单记录、讲解一些初级阶段常用的用法。

STL是C++的一个标准模板库，其中包含了许多在计算机领域常用的基本数据结构以及基本算法。STL主要依赖于模板，使得STL具有广泛的通用性。这篇文章旨在介绍一些常用的STL工具及其用法。

Algorithm

• 该头文件涉及许多常用的功能，例如比较、交换、查找、遍历、绝对值、复制、修改、反转、排序等。

具体用法

/**
	稍微列举部分可能用到的
**/
#include <iostream>
#include <algorithm>
#include <cstdio>
using namespace std;

int main () {
	//排序
	int a[5] = {5, 1, 2, 3,7};
	sort (a, a+5);
	// stable_sort (a, a+5);
	for (int i = 0; i < 5; i++)
		cout << a[i] << " ";
	cout << endl;

	// 反转
	reverse(a, a+5);
	for (int i = 0; i < 5; i++)
		cout << a[i] << " ";
	cout << endl;

	// 绝对值
	cout << abs(-5) << endl;

	// 最大值最小值
	cout << max(5, 3) << " " << min(5, 3) << endl;

	// 交换
	int x = 1, y = 2;
	swap (x, y);
	cout << x << " " << y << endl;

	// 赋值函数fill
	int b[4] = {1, 2, 3, 4};
	fill (b, b+4, -1);
	for (int i = 0; i < 4; i ++)
		cout << b[i] << " ";
	cout << endl;

	//求全排列的下一个顺序, next_permutation若有下一个全排列返回true没有则返回false
	char str[3] = {'a', 'b', 'c'};
	do {
		cout << str << endl;
	}while (next_permutation(str, str+3));
    //.....
	return 0;
}

Container

vector

vector这个容器实际上是加强版的数组。数组在定义的时候长度就被确定下来了，但是vector容器随着添加的数据量增加，它的长度也会随之增加。容器可以存个种类型的数据。

使用时包含头文件#include

初始化（常用）

vector<int> vec; // 整型
vector<char> vec1; // 字符型

int b[4] = {1, 2, 3, 4};
vector<int> a(b, b+4); // 用数组赋值

vector<int> c(10); // 10个长度的整型
vector<int> c1(10, 1); // 10个长度的整型，且每个元素为1
vector<int> c2(c)  // 用c赋值创建c2

常用函数方法

方法	作用
vec.push_back()	在vector末尾添加一个元素
vec.begin() vec.end()	返回vector首尾迭代器
vec.front() vec.back()	返回vector首尾元素
vec.size()	返回vector中元素的个数
vec.pop_back()	删除vector最后一个元素
vec.capacity()	返回内存中总共容纳的元素个数
vec.empty()	返回1表示空，0表示不为空
vec.clear()	清空vector

vector容器也可通过[]方式来访问，第一个下标和数组相同是0，例如vec[0]。

---

stack

stack翻译过来是栈的意思，是一种基础的数据结构。它的特点是先进后出，栈中可以存放各种数据类型，也包括自定义的数据类型。

声明：#include <stack>

使用栈，需要知道一个几个概念

• 栈顶：栈顶部的元素（进出栈都必须经过栈顶）
• 进栈：进入栈中（压栈）
• 出栈：从栈中出去（弹栈）

初始化（常用）

stack<int> s;
stack<char> t;

struct node {
	...
};
stack<node> n;

常用函数方法

方法	作用
s.top()	返回栈顶元素
s.empty()	判断为空返回1，否则0
s.size()	返回栈中元素个数
s.push()	压栈
s.pop()	弹栈

queue

queue表示队列，是一种基本数据结构。特点是先进先出，想象成排队买票的过程，先排队的先买票，后排队的后买票。

声明：#include <queue>

初始化（常用）

queue<int> s;
queue<char> t;

struct node {
	...
};
queue<node> n;

常用函数方法

方法	作用
q.front() q.back()	返回队首、队尾元素
q.empty()	判断为空返回1，否则0
q.size()	返回队列长度
q.push()	从队尾添加一个元素
q.pop()	从队首删除一个元素

清空队列只能一个一个弹出。另外，队列是不能随机访问的。

priority_queue

priority_queue也是队列的一种，是优先队列。普通的队列是一种先进先出的数据结构，但是优先队列中的元素被赋予了优先级，优先级高的元素排在队列前，优先出队列。优先级的规则可以由自定义。

优先队列具有所有队列的基本操作，本质上是一个堆。默认是大顶堆，降序序列。

声明：

#include <queue>

初始化（常用）

priority_queue <int> q; // 默认从大到小

struct node {
	...
};
priority_queue <node> q1;

priority_queue <int, vector<int>, greater<int> > t; // 小顶堆，从小到大

常用函数方法

方法	作用
q.empty()	判断为空返回1，否则0
q.size()	返回队列长度
q.push()	从队尾添加一个元素
q.pop()	从队首删除一个元素
q.top()	访问队首元素

自定义优先级

需要注意的是，优先队列模板中带3个参数，priority_queue<Type, Container, Functional>。Type表示数据类型，Container表示存储数据的容器，Functional为元素的比较方式。后两个参数可以不写，Container默认是Vector，比较方式默认的是operator <，即大顶堆，降序。

对于自定义的数据结构，需要自定义排序规则，那么就需要重写operator<。

struct node {
	int x, y;
	node (int x1, int y1):x(x1), y(y1) {}
};
// 小顶堆
bool operator < (node a, node b) {
	if (a.x == b.x) return a.y > b.y; // x相等，按照y从小到大升序
	return a.x > b.x; // x大的优先级低，按照x从小到大升序
}
//大顶堆
bool operator < (node a, node b) {
	if (a.x == b.x) return a.y < b.y; // x相等，按照y从大到小升序
	return a.x < b.x; // x小的优先级低，按照x从大到小升序
}

//小顶堆，写在结构体内部
struct node {
	int x, y;
	node (int x1, int y1):x(x1), y(y1) {}
	bool operator < (const node &a) const { //小顶堆，按照x升序
		if (x == a.x) return y > a.y;
		return x > a.x;
	}
};
priority_queue <node> q;

也可以自定义比较函数cmp，作为第3个参数，此时容器参数不能省略

struct node {
	int x, y;
	node (int x1, int y1):x(x1), y(y1) {}
};

struct cmp {
	bool operator() (node a, node b) {
		if (a.x == b.x) return a.y > b.y;
		return a.x > b.x;
	}
};

priority_queue <node, vector<node>, cmp > q;

deque

deque是一种双端队列，普通的队列是先进先出，而双端队列既可以从队首进出，也可以从队尾进出。

而deque和queue不同的地方在于，可以通过下标访问其中的元素，也就是支持随机访问。

初始化（常用）

#include <queue>

struct node {
	...
};
deque<int> a;
deque<node> b;

常用函数方法

方法	作用
q.push_front() q.push_back()	在队首、队尾插入元素
q.front() q.back()	获取队首、队尾元素
q.pop_front() q.pop_back()	队首、队尾出队一个元素
q.begin() q.end()	返回队首、队尾的迭代器
q.clear()	清空队列

set

set可以理解成一个集合，这个集合的特点就是其中的元素无重复。假定集合中已有一个元素，那么添加相同的元素进去是无效的，还是只有那一个唯一的元素。同时set中的元素是默认升序的。（红黑树实现）

初始化（常用）

#include <set>
queue<int> s;
queue<char> t;

struct node {
	...
};
queue<node> n;

常用函数方法

方法	作用
s.begin() s.end()	返回集合首尾迭代器
s.insert(k)	集合中插入元素k
s.erase(k)	集合中删除元素k
s.size()	返回集合元素个数
s.empty()	判断集合是否为空
s.clear()	清空集合

map

map是一种关联容器，提供数据一种一对一的映射关系（每一个元素都有一个唯一的关键字，这个关键字对应一个键值）。map也是红黑树实现的，它的好处在于可以快速方便的增加、删除、查找、遍历等。

初始化（常用）

map <int, char> m;
m.insert(pair<int, char>(65, 'A'));
m.insert(map<int, char>::value_type (66, 'B'));
m[67] = 'C';

使用insert方法插入时，会保证key（map中的第一个参数）的唯一性，有相同的key值插入是不会成功的。

但是m[67] = 'C'，这种方式会直接造成覆盖。

常用函数方法

方法	作用
m.begin() m.end()	返回第一个和最后一个迭代器位置
m.insert(map<Type, Type>::value_type())	插入元素，包含关键字和对应值
m.count(k)	查看关键字为k的元素个数（map特性，只能为0或者1）
m.find(k)	查关键字为k元素，有返回迭代器位置没有返回end位置
m.erase()	可根据关键字、迭代器删除（也可成片删除）
m.lower_bound() m.upper_bound()	返回键值>=、＜=给定元素的第一个迭代器位置
m.size()	返回map中元素个数
m.clear()	删除所有元素

Iterator

简单来说，可以用于迭代遍历STL中各种容器的数据类型。

类似于指针，可以指向要访问的索引的值。

简单用法

/**
	遍历set、map等
**/
#include <iostream>
#include <map>
#include <set>
#include <iterator>
using namespace std;

int main () {
	map <int, char> m;
	map <int, char>::iterator it;
	m.insert(map<int, char>::value_type (66, 'B'));
	m.insert(pair<int, char>(65, 'A'));
	m[67] = 'C';
	for (it = m.begin(); it != m.end(); it++)
		cout << it->first << " " << it->second << endl;
	cout << endl;

	vector<int> v;
	vector<int>::iterator it_v;
	for (int i = 1; i <= 10; i++)
		v.push_back(i);
	for (it_v = v.begin(); it_v != v.end(); it_v++)
		cout << *it_v << " ";
	cout << endl;

	set <int> s;
	set <int>::iterator it_s;
	for (int i = 1; i <= 10; i++)
		s.insert(i);
	for (it_s = s.begin(); it_s != s.end(); it_s++)
		cout << *it_s << " ";
	cout << endl;
	return 0;
}

-------------------------------------
// 可以进行查找等
#include <iostream>
#include <map>
using namespace std;

int main () {
	map <int, char> m;
	map <int, char>::iterator it;
	m.insert(map<int, char>::value_type (66, 'B'));
	m.insert(pair<int, char>(65, 'A'));
	m[67] = 'C';
	it = m.find(66);
	if (it != m.end())
		cout << it->first << " " << it->second;
	return 0;
}