挑战程序设计(算法和数据结构)—数据结构（STL总结）

STL（Standard Template Library)简介

栈

头文件#include <stack>
使用 stack<int> S;
成员函数

函数名	表功能	复杂度
size()	返回栈的元素数目	O(1)
top()	返回栈顶的元素	O(1)
pop()	从栈中取出并删除元素	O(1)
push(x)	向栈中添加元素x	O(1)
empty()	在栈为空时返回true	O(1)
swap(s1,s2)	将栈s1和桟s2的数据进行交换，相当于两个栈互换了个名字。这是c++11的标准。并非成员函数！c++11标准也有一个成员函数swap，但是既然都是11标准的，这个写起来更形象。

队列

普通队列

头文件#include <queue>
使用queue<int> Q
成员函数

函数名	表功能	复杂度
size()	返回队列的元素数目	O(1)
front()	返回队头的元素	O(1)
back()	返回对列末尾元素	O(1)
pop()	从队列中取出并删除元素	O(1)
push(x)	向队列中添加元素x	O(1)
empty()	在对列为空时返回true	O(1)

优先队列

• 头文件：#include <queue>
• 先出队列的是优先级最高的元素。
• 使用priority_queue<int> pq;(默认:值越大，优先级越高)。
• 注意：取元素的方法由queue的front()变为top()。
• priority_queue<int，vector<int>, greater<int> > pq;值越小，优先级越大，注意最后两个">"中间要有空格。
• 自定义类型需要自己定义优先级比较函数。
• 优先队列使用堆结构来实现，堆的操作复杂度为O（logn）。

具体情况见代码：

struct cmp1{ 
    bool operator ()(int &a,int &b){ 
        return a>b;//最小值优先 
    } 
}; 

struct node {     
　　int x, y;     
　　bool operator < (const node&a) const 
　　{         
　　　　return x > a.x;    //结构体中，x小的优先级高     
　　}
};

priority_queue<int，vector<int>, cmp1 > pq;// 其中，第二个参数为容器类型。第三个参数为比较函数。
priority_queue<node>q;   //定义方法
//在该结构中，y为值, x为优先级。
//通过自定义operator<操作符来比较元素中的优先级。
//在重载”<”时，最好不要重载”>”，可能会发生编译错误

双端队列

头文件：#include <deque>
使用：deque<int>s1;
成员函数

函数名	表功能	复杂度
size()	返回队列的元素数目	O(1)
front()	返回队头的元素	O(1)
back()	返回对列末尾元素	O(1)
pop_front()	删除队列中最前面的元素	O(1)
pop_back()	删除队列中最后面的元素	O(1)
push_front(x)	向队列首部添加元素x	O(1)
push_back(x)	向队列尾部添加元素x	O(1)
empty()	在对列为空时返回true	O(1)
clear()	清空队列中的所有元素	O(n)

• 注意：支持与vector类似的随机访问（O(1)）：int x=Q[3];

vector(动态数组)

头文件#include <vector>
使用vector <int> V
成员函数

函数名	表功能	复杂度
size()	返回向量的元素数目	O(1)
begin()	返回指向向量开头的迭代器	O(1)
end()	返回指向向量末尾（最后一个元素的后一个位置)的迭代器	O(1)
push_back(x)	在向量末尾添加元素x	O(1)
pop_back()	删除向量的最后一个元素	O(1)
empty()	在向量为空时返回true	O(1)
insert(p,x)	向向量的位置p处插入元素x（该p是迭代器）	O(n)
erase( p)	删除向量中位置p的元素（该p是迭代器）	O(n)
clear()	删除向量中的所有元素	O(n)

vector技巧
1.初始化(5种)
vector<int>vec; //初始化为空

vector<int>vec(v1);//用另一个vector来初始化，即构造一个副本

vector<int>vec(n, i);//大小为n，并全部初始化为元素i （常用）

vector<int>(n);//构造大小为n的容器，没有初始化里面的元素

vector<int>{1,2,3,4}; //构造大小为4，并初始化里面的各个元素

2.遍历容器

vector<int>::iterator it;
for(it=vec.begin();it!=vec.end();it++){
	vec[it]=0;
}

3.调整空间

vec.capacity();//获取容器分配的存储空间，区别于vec.size()
vec.resize(n+m);//调整vec的大小变为n+m，同时还可以通过该函数调整大小删除末尾一些数据

4.vector经常用到的一些函数功能。
需加头文件#include<algorithm>

sort(vec.begin(),vec.end());//对元素排序
reverse(vec.begin(), vec.end());//反转容器
swap(vec[i],vec[j]);//交换元素

参考自C++容器vector的常用成员函数

list(双向链表)

头文件#include <list>
使用list<int> L
成员函数

函数名	表功能	复杂度
size()	返回表的元素数目	O(1)
begin()	返回指向表开头的迭代器	O(1)
end()	返回指向表末尾（最后一个元素的后一个位置)的迭代器	O(1)
push_front(x)	在表的开头添加元素x	O(1)
push_back(x)	在表的末尾添加元素x	O(1)
pop_front()	删除位于表开头的元素	O(1)
pop_back()	删除位于表末尾的元素	O(1)
empty()	在向量为空时返回true	O(1)
insert(p,x)	在表的位置p处插入元素x（该p是迭代器）	O(1)
erase（p）	删除表中位置p的元素（该p是迭代器）	O(1)
clear()	删除表中的所有元素	O(n)

set(集合)

头文件#include <set>
使用set<int> S

• set是元素值进行排序的集合，所插入的元素在集合中唯一，不存在重复元素。如果是结构体需要重载"<",来排序元素。
• set由二叉搜索树实现，而且对树进行了平衡处理，使得元素在树中分布较为均匀，因此能保持搜素、插入、删除操作的复杂度在O(logn)。

成员函数：

函数名	表功能	复杂度
size()	返回set中的元素数目	O(1)
begin()	返回指向set开头的迭代器	O(1)
end()	返回指向set末尾(最后一个元素的后一个位置)的迭代器	O(1)
clear()	删除set中的所有元素	O(n)
insert(x)	在set中插入元素x	O(logn)
count(x)	返回某个值元素x的个数
erase（x）	删除含有x的元素	O(logn)
find(x)	搜索与x一致的元素，并返回指向该元素的迭代器。没有与x一致的元素，则返回末尾end()	O(logn)
同时注意STL中有关于set集合并集和交集的操作set_union和set_intersection。还有空集合的声明set<int>()。参考题目：12096 The SetStack Computer

map(键值对集合)

头文件#include <map>
使用map<string, int> T(以string为键的int型元素)

• map集合以键与值组合为元素，集合以值作为排序标准，集合中各元素的键唯一，不存在重复。
• 可以使用"[ ]"来访问指定键对应的值或迭代器来访问每一对键和值。
• map和set一样通过平衡二叉搜索树来实现，因此元素的插入、删除、搜索以及"[ ]"运算的复杂度均为O(logn)
• map中的key默认是以less<>升序对元素排序（排序准则也可以修改），也就是说key必须具备operator<对元素排序，而平常我们的用的基本上都是基本类型元素作为key，所以就不存在这个问题了。如果是结构体需要重载"<",来排序key值。
  例子：

struct Puzzle
{
    int f[N2];
    int space;
    string path;
    bool operator < (const Puzzle &p) const {
        for(int i=0; i<N2; i++)
        {
            if(f[i]==p.f[i]) continue;
            return f[i] < p.f[i];//代表升序排列
            }
        return false;
    }
};

成员函数：
key为键，val为值

函数名	表功能	复杂度
size()	返回map中的元素数目	O(1)
begin()	返回指向map开头的迭代器	O(1)
end()	返回指向map末尾(最后一个元素的后一个位置)的迭代器	O(1)
clear()	删除map中的所有元素	O(n)
insert((key,val))	在map中插入元素（key,val）	O(logn)
erase（key）	删除含有key的元素	O(logn)
count(key)	返回的是被查找元素key的个数
find(key)	搜索与key一致的元素，并返回指向该元素的迭代器。没有与key一致的元素，则返回末尾end()	O(logn)

其它

拓展：STL的结构体pair

• 无头文件
• 使用pair<string, int> T来初始化或直接用make_pair(x,y)来建立一个结构体元素
• 第一个元素可以使用first访问，第二个元素可以使用second访问。eg:T.first和T.second

其他知识点：

• 能进行算术运算的迭代器只有随机访问迭代器，要求容器元素存储在连续内存空间里，vector，string，deque的迭代器是有加减法的，但是map，set，multimap,multiset的迭代器是没有加减法的，list也不可以 。

algorithm

sort(排序)

1. 全局函数形式的自定义排序

//定义一个节点
struct node {
	int a;
	string name;
};

//以全局函数的形式自定义排序函数
bool cmp(node x, node y) {
	return x.a < y.a;  // 从小到大排序
}

vector<node> v;
sort(v.begin(), v.end(), cmp);

2. 结果体内部的自定义排序

struct node {
	int a;
	string name;
	bool operator < (const node&a) const 
　　{         
　　　　return x < a.x;    // 从小到大排序  
　　}
};

vector<node> v;
sort(v.begin(), v.end());

• min、max
• swap(a,b)（交换a、b的值) 支持所有的内置类型以及用户自己定义的结构体。