STL笔记

stack

栈的原则：先进后出
#include< stack >用来将STL的stack包含到程序中
stack< int > S; 是一个声明，用于生成管理int型元素的栈。
stack中的成员函数：

函数名	功能
size()	返回栈的元素数
top()	返回栈顶的元素
pop()	从栈中取出并删除元素
push(x)	向栈中添加元素x
empty()	在栈为空时返回true

stack的使用代码

#include<stdio.h>
#include<algorithm>
#include<iostream>
#include<stack>
using namespace std;

int main()
{
	stack<int> S;
	S.push(1);//向栈中压入1 
	S.push(2);//向栈中压入2 
	S.push(3);//向栈中压入3
	
	printf("栈的大小为："); 
	printf("%d\n",S.size());//求栈的大小=3；
	
	printf("栈顶元素为：");
	printf("%d\n",S.top()); //求栈顶元素“先进后出”，栈顶元素为3；
	
	printf("栈是空栈吗？\n");//判断栈是否为空！ 
	if(S.empty())
	printf("YES\n");
	else
	printf("NO\n");
	
	S.pop();//取出栈顶元素 
	printf("取出栈顶元素后，接着的栈顶元素为："); 
	printf("%d\n",S.top());//取出栈顶元素后，剩余栈顶为2；
	S.pop();
	S.pop();//取出三次，栈应该为空 
	
	printf("栈是空栈吗？\n");//继续判断栈是否为空！ 
	if(S.empty())
	printf("YES\n");
	else
	printf("NO\n");
	return 0;
} 

queue

队列的原则：先进先出
#include< queue >用来将STL中的queue包含到程序中。
queue< int > Q;是一个声明，用于生成管理int型元素的队列。

queue中的成员函数

函数名	功能
size()	返回队列的元素数
front()	返回队头的元素
pop()	从队列中取出并删除元素
push(x)	向队列中添加元素x
empty()	在队列为空时返回true

队列的使用代码

#include<stdio.h>
#include<algorithm>
#include<iostream>
#include<queue>
using namespace std;

int main()
{
	queue<int> 	Q;
	Q.push(1);//向队列中压入1 
	Q.push(2);//向队列中压入2 
	Q.push(3);//向队列中压入3
	
	printf("队列的大小为："); 
	printf("%d\n",Q.size());//求队列的大小=3；
	
	printf("队头元素为：");
	printf("%d\n",Q.front()); //求队头元素“先进先出”，队头元素为1；
	
	printf("队是空队列吗？\n");//判断队列是否为空！ 
	if(Q.empty())
	printf("YES\n");
	else
	printf("NO\n");
	
	Q.pop();//取出队头元素 
	printf("取出队头元素后，接着的队头元素为："); 
	printf("%d\n",Q.front());//取出队头元素后，剩余栈顶为2；
	Q.pop();
	Q.pop();//取出三次，队列应该为空 
	
	printf("队是空队列吗？\n");//继续判断队列是否为空！ 
	if(Q.empty())
	printf("YES\n");
	else
	printf("NO\n");
	return 0;
} 

vector

vector是一种可以用作动态数组的数据结构
#include< vector >是用来将STL的vector包含到程序中
vector< double > V;是一个声明，用于生成管理double型元素的向量。
vector中的成员函数：

函数名	功能
size()	返回向量的元素数
push_back(x)	在向量末尾添加元素x
pop_back()	删除向量的最后一个元素
begin()	返回指向向量开头的迭代器
end()	返回指向向量末尾（最后一个元素的后一个位置）的迭代器
insert(p,x)	在向量的位置p处插入元素x
erase( p )	删除向量中位置p的元素
clear()	删除向量中所有元素

这里的迭代器可以看成一个指针
vector的使用代码

#include<stdio.h>
#include<algorithm>
#include<iostream>
#include<vector>
using namespace std;

int main()
{
	vector<double> V;
	
	V.push_back(0.1);
	V.push_back(0.2);
	V.push_back(0.3);
	V[2]=0.5;
	for(int i=0;i<V.size();i++)
	printf("%.1lf ",V[i]);//0.1 0.2 0.5
	printf("\n");
	
	V.insert(V.begin()+2,0.6);
	for(int i=0;i<V.size();i++)
	printf("%.1lf ",V[i]);//0.1 0.2 0.6 0.5
	printf("\n");
	
	V.erase(V.begin()+1);
	for(int i=0;i<V.size();i++)
	printf("%.1lf ",V[i]);//0.1 0.6 0.5
	printf("\n");
	
	V.push_back(0.8);
	for(int i=0;i<V.size();i++)
	printf("%.1lf ",V[i]);//0.1 0.6 0.5 0.8	
	printf("\n");
	
	return 0;
}

list

#include< list >用来将STL的list包含到程序中。
list< char > L;是一个声明，用于生成管理char型元素的双向链表。
list中的成员函数：

函数名	功能
size()	返回表的元素数
begin()	返回指向表开头的迭代器
end()	返回指向表末尾（最后一个元素的后一个位置）的迭代器
push_front(x)	在表的开头添加元素x
push_back(x)	在表的末尾添加元素x
pop_front()	删除位于表头的元素
pop_back()	删除位于表末尾的元素
insert(p,x)	在表的位置p处插入元素x
erase( p )	删除表中位置p的元素
clear()	删除表中所有元素

list既可以像vector一样通过“[ ]”运算符直接访问特定元素，也可以用迭代器逐个进行访问。
list的使用代码

#include<stdio.h>
#include<algorithm>
#include<iostream>
#include<list>
using namespace std;

int main()
{
	list<char> L;
	L.push_front('b');  //[b]
	L.push_back('c');  //[bc]
	L.push_front('a'); //[abc]
	
	printf("%c\n",L.front());// a
	printf("%c\n",L.back()); //c
	
	L.pop_front(); //[bc]
	L.push_back('d');//[bcd]
	
	printf("%c\n",L.front());// b
	printf("%c\n",L.back()); //d
	
	return 0;
}

set

set是根据元素值进行排序的集合，所插入的元素在集合中唯一，不存在重复的元素。
#include< set >用来将STL中的set包含到程序中。
set< int > S;是一个声明，用于生成管理int型元素的集合。

set中的成员函数：

函数名	功能
size()	返回set中的元素数
clear()	清空set
begin()	返回指向set开头的迭代器
end()	返回指向set末尾的迭代器
insert(key)	向set中插入元素key
erase(key)	删除含有key的元素
find(key)	搜索与key一致的元素，并返回指向该元素的迭代器。没有与key一致的元素，则返回末尾end()

set由二叉搜索树实现，而且对树进行了平衡处理，使得元素在树中分布比较均匀。

set的使用代码：

#include<stdio.h>
#include<algorithm>
#include<iostream>
#include<set>
using namespace std;

int main()
{
	set<int> S;
	
	S.insert(9);
	S.insert(1);
	S.insert(8);
	S.insert(6);
	S.insert(2);
	
	printf("set中的元素数为：%d\n",S.size());
	for(set<int>::iterator it=S.begin();it!=S.end();it++)
	printf("%d ",*it);//1 2 6 8 9
	printf("\n");
	
	S.erase(8);
	for(set<int>::iterator it=S.begin();it!=S.end();it++)
	printf("%d ",*it);//1 2 6 9
	printf("\n");
	
	if(S.find(10)==S.end())
	printf("NO found!\n");
	
	return 0;
}

iterator为迭代器
了解迭代器请点击下面这一链接，进行了解：
https://www.cnblogs.com/hdk1993/p/4419779.html

map

map集合以键与值的组合为元素，每个元素拥有1个键和1个值，集合以值作为排序标准。集合中各元素的键唯一，不存在重复。map可以看作是一种能使用任意类型下标的关联式容器。
#include< map >用来将STL的map包含到程序中。
map< char,int > T;是一个声明，用于生成关联数组，该关联数组管理以char为键的int型元素。这里需要在<>中指定一组（一对）键和值的类型。

map中的成员函数：

函数名	功能
size()	返回map中的元素数
clear()	清空map
begin()	返回指向map开头的迭代器
end()	返回指向map末尾的迭代器
insert( (key,val) )	向map中插入元素(key,val)
erase(key)	删除含有key的元素
find(key)	搜索与key一致的元素，并返回指向该元素的迭代器。没有与key一致的元素，则返回末尾end()

map的使用代码：

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

int main()
{
	map<char,int> T;
	T.clear();
	
	T['A']=0;
	T['B']=1;
	T['C']=2;
	
	T['C']+=32;
	T.insert(make_pair('E',5));
	printf("%d\n",T.size());
	map<char,int>::iterator it;
	for(it=T.begin();it!=T.end();it++)
	{
		pair<char,int> item=*it;
		printf("%c --> %d\n",item.first,item.second);
	}
	T.erase('A');
	for(it=T.begin();it!=T.end();it++)
	{
		pair<char,int> item=*it;
		printf("%c --> %d\n",item.first,item.second);
	} 
	return 0;
}

pair为STL中提供的结构体模板，其第一个元素可用first访问，第二个元素用second访问。
此代码结果显示：

priority_queue

priority_queue是一种能根据元素优先级进行插入、引用、删除操作的队列。执行这些操作的函数与queue相同。在priority——queue中，开头元素永远都是拥有最高优先级的元素。优先级的基准可由我们指定。

priority_queue中的成员函数与queue相同，此处不再列出，如有需要，请见上文中queue部分

priority_queue的使用代码：

#include<stdio.h>
#include<algorithm>
#include<iostream>
#include<queue>
using namespace std;

int main()
{
	priority_queue<int> P;
	P.push(1);
	P.push(8);
	P.push(5);
	P.push(6);
	
	printf("%d\n",P.top());//8
	P.pop();
	printf("%d\n",P.top());//6
	P.push(12);
	printf("%d\n",P.top());//12
	P.pop();
	P.pop();
	printf("%d\n",P.top());//5
	P.pop();
	printf("%d\n",P.top());//1
	return 0;
}

元素类型为int型时，priority_queue默认最大的元素优先级最高，将其优先取出。

搜索

- 迭代器（简单）

迭代器是一种对象，用于对STL容器的元素进行迭代处理。它指向容器内部的特定位置。

迭代器的基本运算符：

运算符	含义
++	让迭代器指向下一元素
==、!=	判断两个迭代器是否指向同一位置并返回结果
=	将右侧的值带入左侧迭代器所引用元素的位置
*	返回该位置的元素

常见的函数：begin()、end()

- 二分搜索

lower_bound是一种应用于有序数据范围内的算法，它可以返回一个迭代器，这个迭代器指向第一个不小于指定值value的元素。
同理，
binary_bound返回的是一个布尔值，binary_search() 能告诉我们元素是否在这个序列中，但当它在序列中时，却不能告诉我们它的位置。
upper_bound返回的迭代器指向第一个大于指定值value的元素。

通过这个，我们既可以找出第一个能够插入value的位子，又能维持指定范围内的元素顺序（有序状态）。

使用二分搜索的代码：

#include<stdio.h>
#include<algorithm>
#include<iostream>
using namespace std;

int main()
{
	int A[14]={1,1,2,3,3,3,5,6,8,9,9,10,11,12};
	int *pos;
	int cur;
	pos=lower_bound(A,A+14,3);
	cur=distance(A,pos);
	printf("A[%d]=%d\n",cur,*pos);//A[3]=3
	
	if(binary_search(A,A+14,3))
	printf("YES\n");
	else
	printf("NO\n");//YES
	
	pos=upper_bound(A,A+14,3);
	cur=distance(A,pos);
	printf("A[%d]=%d\n",cur,*pos);//A[6]=5
	return 0;
}

lower_bound()的前两个参数用来指定作为对象的数组或容器的范围。

distance()函数返回两个指针间的距离