STL常用API(vector、list、deque、map、set、queue、stack、algorithm)

本文用于总结STL常用API！！！本文代码已经上传到github中。

1. STL(标准模板库)

STL提供了一组表示容器、迭代器、函数对象和算法的组件。容器是用来存储若干个类型相同的值；迭代器用来遍历容器；函数对象是类似于函数的对象；算法是完成特定任务的方法。该库包含了诸多在计算机科学领域里所常用的基本数据结构和基本算法。

2. 容器的种类？

（本文图片来源于博客：https://www.cnblogs.com/kuotian/p/5314763.html）

a. 序列(顺序)容器：各元素之间有顺序关系。元素的排列次序与元素值无关，而是与元素添加到容器里的次序有关。

常用容器：vector(向量)、list(双向链表)、deque(队列)

序列容器的共同方法：

不同容器特有的方法：

                                                                vector容器

#include 
#include 

using namespace std;

//遍历vector
void print_vector(vector vec)
{
	//方法一
	for (int i = 0; i < vec.size(); i++)
		cout << vec[i] << " ";
	cout << endl;

	//方法二
	vector::iterator ite = vec.begin();
	while (ite != vec.end())
	{
		cout << *ite << " ";
		ite++;
	}
	cout << endl;
}
void main()
{
	//对象初始化
	vector vec;
	vector vec_0(5);//定义长度，初识值为0
	vector vec_3(5, 3);//定义长度，初识值为3

	//遍历vector容器
	print_vector(vec_0);

	//vector推入元素
	vec.push_back(1);

	//第一个元素之前插入5个值为3的元素
	vec.insert(vec.begin(), 5, 3);

	//最后一个元素之后插入5个值为3的元素
	vec.insert(vec.end(), 5, 3);
	print_vector(vec);

	//删除最后一个元素
	vec.pop_back();

	//删除区间的元素
	vec.erase(vec.begin() + 2, vec.end());

	//清空vector
	vec.clear();

	//判断是否为空
	bool empty_result = vec.empty();
	cout << empty_result << endl;
}

                                                                list容器

#include 
#include 

using namespace std;

//遍历list
void print_list(list ls)
{	
	list::iterator ite = ls.begin();
	while (ite != ls.end())
	{
		cout << *ite << " ";
		ite++;
	}
	cout << endl;
}
void main()
{
	//list初始化
	list ls;
	list ls1(5);//定义长度，初识值为0
	list ls2(5, 3);//定义长度，初识值为3

	//遍历lisg
	print_list(ls1);

	//最后一个元素之后插入元素
	ls.push_back(1);
	//第一个元素之前插入元素
	ls.push_front(0);
	print_list(ls);

	//获得第一个、最后一个元素
	int first_val = ls.front();
	int last_val = ls.back();
	cout << first_val << endl;

	//删除最后一个元素、第一个元素
	ls.pop_back();
	ls.pop_front();

	//判断list是否为空
	bool empty_result = ls.empty();

	//resize list的长度
	ls.resize(5);
	ls.resize(5, 3);//指定填充值
	print_list(ls);

	//清空list
	ls.clear();

	//替换list元素为5个3
	ls.assign(5, 3);
	ls.assign(ls1.begin(), ls1.end());
	print_list(ls);

	//交换两个list
	swap(ls1, ls2);
	print_list(ls1);

	//list的翻转
	reverse(ls.begin(), ls.end());

	//合并两个list
	ls.merge(ls1);
	print_list(ls);

	//在指定位置插入元素
	ls.insert(ls.begin(), 2, 100); //在开始位置插入2个100
	print_list(ls);

	//删除区间元素
	ls.erase(ls.begin(), ls.end());

	//删除指定所有值得元素
	ls.remove(0);

}

                                                                deque容器

#include 
#include 

using namespace std;

//遍历deque
void print_deque(deque deq)
{
	//正向队列遍历
	deque::iterator ite = deq.begin();
	while (ite != deq.end())
	{
		cout << *ite << " ";
		ite++;
	}
	cout << endl;

	//反向队列遍历
	deque::reverse_iterator r_ite;
	for (r_ite = deq.rbegin(); r_ite != deq.rend(); r_ite++)
	{
		cout << *r_ite << " ";
	}
	cout << endl;
}

void main()
{
	//初始化
	deque deq = { 1,2,3,4,5 };

	//判断容器是否为空
	if (deq.empty())
		cout << " deque is empty ." << endl;

	//遍历容器
	print_deque(deq);

	//获得容器中第一个、最后一个元素、最大允许元素的数量
	cout <<"the first data is :"<< deq.front() << endl;
	cout << "the last data is :" << deq.back() << endl;
	cout << "the number of deque is:" << deq.max_size() << endl;

	//获得指定索引的元素
	cout << deq.at(0) << endl;

	//operator[]下标运算符重载
	cout << deq[0] << endl;

	//operator=赋值运算符重载
	deque deq_;
	deq_ = deq;
	print_deque(deq_);

	//清除容器中的所有元素
	deq_.clear();
	print_deque(deq_);

	//复制2个6到容器中
	deque deq_1;
	deq_1.assign(2, 6);
	//deque deq_1(2, 6); //等价此初始化方式
	print_deque(deq_1);

	//复制指定地址区间的元素到容器中
	deque deq_2;
	deq_2.assign(deq.begin(), deq.begin() + 2);
	print_deque(deq_2);

	//在指定位置(地址)插入元素
	deq.insert(deq.end(), 7);
	deq.insert(deq.end(), 2, 7);
	//在指定位置(地址)插入区间(地址)的元素
	deq.insert(deq.end(), deq_2.begin(), deq_2.end());
	print_deque(deq);

	//删除指定位置(地址)、指定区间(地址)的元素
	deq.erase(deq.begin());
	deq.erase(deq.begin(), deq.begin()+1);
	print_deque(deq);

	//在末尾、开头添加或删除元素
	deq.push_back(8);
	deq.pop_back();
	deq.push_front(9);
	deq.pop_front();
	print_deque(deq);

	//重新定义容器的大小
	deq.resize(deq.size() + 2);
	deq.resize(deq.size() - 2);
	print_deque(deq);

	//交换容器
	deq.swap(deq_1);
	//swap(deq, deq_1);
	print_deque(deq);

}

b. 关联容器：元素以非线性的树结构存入容器中。根据元素的特点进行排序和读取。

常用容器：map(集合)、multimap(多重集合)、set(映射)、multiset(多重映射)

                                                                  map容器

#include 
#include 
#include 

                                                                  set容器

#include 
#include 

using namespace std;
void print_set(set set_)
{
	// 正向遍历
	set::iterator ite;
	for (ite = set_.begin(); ite != set_.end(); ite++)
	{
		cout << *ite << " ";
	}
	cout << endl;
	//反向遍历
	set::reverse_iterator r_ite;
	for (r_ite = set_.rbegin(); r_ite != set_.rend(); r_ite++)
	{
		cout << *r_ite << " ";
	}
	cout << endl;
}

void main()
{
	//初始化
	set set_ = { 1,2,3,4,5 };

	//遍历容器
	print_set(set_);

	//查找指定键的元素
	set::iterator ite;
	ite = set_.find(1);
	cout << *ite << endl;

	//查找指定键出现的次数 0或者1
	cout << set_.count(5) << endl;

	//获得第一个大于等于指定值得元素
	pair::const_iterator, set::const_iterator>pr;
	pr = set_.equal_range(4);
	//获得第一个大于指定值得元素
	cout << *pr.first << endl;
	cout << *pr.second << endl;

	//删除指定位置(地址或键)的元素
	//set_.erase(set_.begin());
	//set_.erase(set_.begin(), ++set_.begin());
	set_.erase(1);
	print_set(set_);

	//返回第一个大于等于key_value的定位器
	cout << *set_.lower_bound(4) << endl;
	//返回最后一个大于等于key_value的定位器
	cout << *set_.upper_bound(4) << endl;
}

c. 容器适配器：让一种已存在的容器类型采用另一种不同的抽象类型的工作方式实现。其本身不能直接保存元素，而是调用另一种顺序容器去实现。

常用容器：queue(队列)、stack(栈)

queue不允许随机访问队列元素，不允许遍历队列，可以进行队列基本操作

stack不允许随机访问栈元素，不允许遍历栈，把使用限制在定义栈的基本操作上

总结：vector封装数组，list封装链表，map和set封装二叉树等

                                                                queue容器

#include 
#include 

using namespace std;

//清空队列
void clear_queue(queue &que)
{
	queue empty;
	swap(empty, que);
}
void print_queue(queue que)
{
	while (!que.empty())
	{
		cout << que.front() << " ";
		que.pop();
	}
}
void main()
{
	queue que;

	//队列压入元素
	que.push(1);
	que.push(2);
	que.push(3);
	que.push(4);
	que.push(5);

	//遍历队列元素
	//print_queue(que);

	//获得队列的元素个数
	cout << que.size() << endl;

	//获得队列第一个元素
	cout << que.front() << endl;

	//删除队列第一个元素
	que.pop();

	//清空队列
	clear_queue(que);
}

                                                                 stack容器

#include 
#include 

using namespace std;

void print_stack(stack st)
{
	while (!st.empty())
	{
		cout << st.top() << " ";
		st.pop();
	}
}
void main()
{
	stack st;
	//将元素压入栈
	st.push(1);
	st.push(2);
	st.push(3);
	st.push(4);
	st.push(5);

	// 用一个栈创建新栈
	//stack st_1(st);
	stack st_1;
	st_1 = st;

	//遍历栈
	print_stack(st_1);
}

                                                                 algorithm

#include 
#include 

using namespace std;
bool cmp_num(int num1, int num2)
{
	return num1 > num2;
}
void print_str(string str)
{
	auto str_begin = str.begin();
	auto str_end = str.end();
	while (str_begin != str_end)
	{
		cout << *str_begin;
		str_begin++;
	}
	cout << endl;
}
void main()
{
	//交换两个元素
	int swap_num1 = 5, swap_num2 = 10;
	swap(swap_num1, swap_num2);
	cout << swap_num1 << " " << swap_num2 << endl;

	//翻转字符串
	string reverse_str = "abcdef";
	//reverse(reverse_str.begin(), reverse_str.end());//翻转整个字符串
	reverse(reverse_str.begin()+2, reverse_str.end());//翻转指定字符串
	cout << reverse_str[2] << endl;

	//根据数据智能选择排序算法  
	int sort_arr[5] = { 3,5,2,7,1 };
	//sort(sort_arr, sort_arr + 5);//默认升序排序
	sort(sort_arr, sort_arr + 5,cmp_num);//降序排序
	cout << sort_arr[0] << endl;

	//获得两个数中较小的数
	int max_min_num1 = 5, max_min_num2 = 10;
	int min_result = min(max_min_num1, max_min_num2);
	int max_result = max(max_min_num1, max_min_num2);
	cout << max_result << endl;

	//获得字符串的所有排列组合 默认升序排列
	string permutation_str = "abc";
	while (next_permutation(permutation_str.begin(), permutation_str.end()))
	{
		print_str(permutation_str);
	}
}