STL介绍及常用算法详解

• STL
  • STL的诞生
  • STL的基本概念
  • STL的六大组件
  • STL中容器、算法、迭代器
  • Vector
  • Queue
  • Stack
  • Deque
  • Set
  • Unordered_set
  • Map
  • Unordered_map

STL

STL的诞生

• 长久以来，软件界一直希望建立一种可重复利用的东西
• C++的面向对象和泛型编程思想，目的就是复用性的提升
• 大多情况下，数据结构和算法都未能有一套标准,导致被迫从事大量重复工作
• 为了建立数据结构和算法的一套标准诞生了STL

STL的基本概念

• STL(Standard Template Library,标准模板库)
• STL从广义上分为: 容器(container) 算法(algorithm) 选代器(iterator)
  容器和算法之间通过迭代器进行无缝连接
• STL几乎所有的代码都采用了模板类或者模板函数

STL的六大组件

STL大体分为六大组件，分别是:容器、算法、迭代器、仿函数、适配器(配接器)、空间配置器

• 1.容器: 各种数据结构，如vector、list、deque、set、map等,用来存放数据
• 2.算法: 各种常用的算法，如sort、find、copy、for_each等
• 3.选代器:扮演了容器与算法之间的胶合剂。
• 4.仿函数:行为类似函数，可作为算法的某种策略.
• 5.适配器:一种用来修饰容器或者仿函数或迭代器接口的东西。
• 6.空间配置器:负责空间的配置与管理

STL中容器、算法、迭代器

一.容器:置物之所也

STL容器就是将运用最广泛的一些数据结构实现出来

常用的数据结构:数组,链表,树,栈,队列集合,映射表等.

这些容器分为序列式容器和关联式容器两种:

• 序列式容器:强调值的排序，序列式容器中的每个元素均有固定的位置(1,3,5,4,2)
• 关联式容器:二叉树结构，各元素之间没有严格的物理上的顺序关系(1,2,3,4,5)

二.算法:问题之解法也

有限的步骤，解决逻辑或数学上的问题，这一门学科我们叫做算法(Algorithms)

算法分为:质变算法和非质变算法

• 质变算法:是指运算过程中会更改区间内的元素的内容。例如拷贝，替换，删除等等
• 非质变算法: 是指运算过程中不会更改区间内的元素内容，例如查找、计数J遍历、寻找极值等

三.迭代器:容器和算法之间粘合剂

提供一种方法，使之能够依序寻访某个容器所合的各个元素，而又无需暴露该容器的内部表示方式每个容器都有自己专属的迭代器

迭代器使用非常类似于指针，初学阶段我们可以先理解迭代器为指针

迭代器种类：

• 输入迭代器：对数据的只读访问，只读，支持-+、==、!=
• 输出迭代器：对数据的只写访问，只写，支持-+
• 前向迭代器：读写操作，并能向前推进迭代器，读写，支持++、==、!=
• 双向迭代器：读写操作，并能向前和向后操作，读写，支持-+、–,
• 随机访问迭代器:随机访问迭代器：读写操作，可以以跳跃的方式访问任意数据，功能最强的迭代器，读写，支持++、-、[n]、-n、<、<=、>、>=

常用的容器中迭代器种类为双向迭代器和随机访问迭代器(后两种用的多)

（源于y总）

Vector

STL中最常用的容器为Vector，可以理解为数组。

#include <iostream>
#include <vector>

using namespce std;

int main()
{
	vector<int> a;
	vector<int> b[233];

	//这两个函数基本所有的STL容器都有
    a.size();//返回vector的大小
	a.empty();//判断是否为空,返回bool值

	a.clear();//清空vector

	//vector还有迭代器的概念，可以用来遍历容器中的元素，相当于指针，(基本不用)
	vector<int>::iterator it = a.begin(); //起始迭代器,指向容器中的第一个元素
	vector<int>::iterator itEnd = a.end();//结束迭代器,指向容器中的最后一个元素的下一个位置
    //左闭右开


	// *a.begin() 与 a[0] 的值相同
	// a.end() - 1 与 a[a.size() - 1] 的值相同


	
	vector<int> a({1,2,3});
    
	cout << a.front() << " " << a[0] << " " << *a.begin() << endl; //1 1 1

	cout << a.back() << " " << a[a.size() - 1] << endl; //3 3

	a.push_back(4); //在末尾添加元素
	a.pop_back(); //删除末尾元素
//遍历
	for(int i = 0;i < a.size();i ++)
        cout << a[i] << " ";
    cout << endl;
	
	for(auto i = a.begin(); i != a.end(); i ++)
        cout << *i << " ";
	cout << endl;

//(范围遍历)
	for(int i : a ) cout << i << " ";
	cout << endl;


	struct Rec
	{
		int x,y;
	};

	vector<Rec> c;
	return 0;
}

Queue

头文件queue主要包括循环队列queue和优先队列priority_queue两个容器。

#include <iostream>
#include <vector>
#include <queue>

using namespcae std;

int main()
{
//队列
    queue<int> q; 
    
	q.push(1); //在队头插入一个元素
	q.pop(); //删除队头元素
	q.front(); //返回队头元素
	q.back(); //返回队尾元素

//优先队列
	priority_queue<int> a; //大根堆
	priority_queue<int, vector<int>, greater<int>> b; //小根堆

	a.push(1); //插入元素
	a.top(); //取最大值
	a.pop(); //删除最大值

    //queue和priority_queue没有clear函数，只需要重新定义一下，即可清空
    q = queue<int>();

	priority_queue<pair<int, int>> c; //二元组


	struct Rec
	{
		int x,y;
		bool operator< (const Rec& t) const //重载大于号
		{
			return x <> t.x;
		}
	};

	priority_queue<Rec> d; //一定要重载一个小于号，否则会报错（此处为大根堆），小根堆要用greater<int>，重载大于号。。


	return 0;
}

队列，优先队列和栈中没有clear函数，因为它们都是容器，容器的clear函数会清空容器中的所有元素，而队列，优先队列和栈中的元素是动态申请的，所以没有必要提供clear函数。

Stack

头文件stack包含栈。

栈和队列是相似的，只不过它是先进后出。（即弹出的元素十最后一个插入的元素）

#incldue <iostream>
#include <stack>

using namespace std;

int main()
{
	stack<int> stk;

	stk.push(1); //压栈
	stk.pop(); //出栈
	stk.top(); //查看栈顶元素

	return 0;
}

Deque

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

#include <iostream>
#include <deque>

using namespace std;

int main()
{
	deque<int> a;
	a[0]; //随机访问一个元素
	a.begin(); //返回指向第一个元素的迭代器
	a.end(); //返回指向最后一个元素的迭代器
	a.front(); //返回队头元素
	a.back(); //返回队尾元素
	a.push_front(1); //在队头插入元素
	a.push_back(2); //在队尾插入元素
	a.pop_front(); //删除队头元素
	a.pop_back(); //删除队尾元素
    
	//不太常用
	/*
	a.size(); //返回队列大小
	a.empty(); //判断队列是否为空
	a.clear(); //清空队列
	a.insert(a.begin() + 1, 3); //在指定位置插入元素
	a.erase(a.begin() + 1, a.begin() + 3); //删除指定范围的元素
	a.swap(b); //交换两个队列的内容
	a.resize(10); //调整队列大小
	a.max_size(); //返回队列最大容量
	a.at(1); //返回指定位置元素
	a[1] = 4; //修改指定位置元素的值
	a.front() = 5; //修改队头元素的值
	a.back() = 6; //修改队尾元素的值
	a.assign(b.begin(), b.end()); //赋值
	*/

	return 0;
}

Set

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

#include <iostream>
#include <set>


using namespace std;

int main()
{
	set<int> a; //元素不能重复
	multiset<int> b; //元素可以重复
    
	//size/empty/clear与vector类似

//set也有迭代器
    
	set<int>::iterator it = a.begin(); //起始迭代器
	it++; //移动到下一个元素
	it--; --it; ++it;//都有

	a.end();//指向最后一个元素的下一个位置

	a.insert(1); //插入元素
	a.find(x); //查找元素x,返回指向元素的迭代器,	
    if(a.find(x) == a.end()) //判断x是否存在于a中

    
	a.lower_bound(x); // 找到大于等于x的最小值，返回指向该元素的迭代器
	a.upper_bound(x); // 找到大于x的最小值，返回指向该元素的迭代器
	a.equal_range(x); // 返回一个pair,第一个为指向x的最小值的迭代器，第二个为指向x的最大值的迭代器

	a.erase(x); // 删除x
	a.count(x); // 返回x在a中出现的次数,存在x返回1（multiset也有，返回x在a中出现的次数），不存在返回0


	struct Rec
	{
		int x,y;
		bool operator< (const Rec& t) const //重载小于号
		{
			return x < t.x;
		}
	}
	set<Rec> c;

	return 0;
}

Unordered_set

头文件 unordered_set 主要包括 unordered_set 和 unordered_multiset 两个容器，它们与 set 和 multiset 类似，但内部实现是哈希表。

Map

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

二元组

#include <iostream>
#include <map>

using namespace std;

int main()
{
	map<string,vector<int>> a;

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

	//size/empty/clear/begin/end均与set类似

	a["abc"] = vector<int>{1,2,3};
	cout << a["abc"][2] << endl; //3

	cout << (a.find("abc") == a.end()) << ednl; //0
	return 0;
}

Unordered_map

头文件 unordered_map 主要包括 unordered_map 和 unordered_multimap 两个容器，它们与 map 和 multimap 类似，但内部实现是哈希表。

unordered都不支持二分

---

补充：

pair

#include <iostream>
#include <utility>


using namespace std;

int main()
{
	pair<int, string> a;
	a = {3, "abc"};

	cout << a.first << " " << a.second << endl; //3 abc

	a = make_pair(4, "def");

	cout << a.first << " " << a.second << endl; //4 def
	return 0；
}