标签：迭代器 模板库 pop 添加 出栈 结构体 遍历 关键字 queue
STL是C++的一个标准模板库，其中包含了许多在计算机领域常用的基本数据结构以及基本算法。STL主要依赖于模板，使得STL具有广泛的通用性。这篇文章旨在介绍一些常用的STL工具及其用法。
具体用法
/**
稍微列举部分可能用到的
**/
#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;
}
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翻译过来是栈的意思，是一种基础的数据结构。它的特点是先进后出，栈中可以存放各种数据类型，也包括自定义的数据类型。
声明：#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表示队列，是一种基本数据结构。特点是先进先出，想象成排队买票的过程，先排队的先买票，后排队的后买票。
声明：#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也是队列的一种，是优先队列。普通的队列是一种先进先出的数据结构，但是优先队列中的元素被赋予了优先级，优先级高的元素排在队列前，优先出队列。优先级的规则可以由自定义。
优先队列具有所有队列的基本操作，本质上是一个堆。默认是大顶堆，降序序列。
声明：
#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和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中的元素是默认升序的。（红黑树实现）
#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 <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() |
删除所有元素 |
简单来说，可以用于迭代遍历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;
}
标签：迭代器 模板库 pop 添加 出栈 结构体 遍历 关键字 queue
原文地址：https://www.cnblogs.com/s-k-p/p/13581731.html
