C++STL！这篇就够了！

以下均为在AOJ中做题时遇到的STL。
附上网站：

https://onlinejudge.u-aizu.ac.jp/courses/lesson/8/ALDS1/all

Top

namespace std

max()/min()对若干元素的使用

int maxx = max({1,2,3,,,});
int minn = min({1,2,3,,,});

-Top

用的少的头文件

二进制

需要#include
bitset(a)返回a的指定位数的二进制数。

// 长度为 4 ，默认每一位为 0；
bitset<4> bs1;
// 将字符串转换为二进制，不足则前面补 0, 较大则取前面部分。若参数为整数，则取后面部分。
string s = "100101"; // char s[] = "100101";
 bitset<8> bs2(s);
// a 的 8 位二进制数；
int a;
bitset<8> b(a);
cout <<  b << endl;

可以通过数组的方式对二进制数赋值/输出。==注意最低位下标为 0 == test函数会对下标越界作出检查，而通过[ ] 访问元素却不会经过下标检查。¹

bitset<4> bs("1011")
// bs[0] = 1; bs[1] = 1; bs[2] = 0; bs[3] = 1;

此外还有一些函数。

bitset<32> bs("100101");
// 求 bs 中 1 的位数；
bs.count(); 
// 求 bs 的大小；
bs.size(); 
 // 求 下标为 i 的元素是否为 1，返回bool类型；
bs.test(i);
// 检查 bs 中是否有 1； 返回bool类型；
bs.any();
// 检查 bs 中是否没有 1； 返回bool类型；
bs.none();
// 检查 bs 中是否全为 1； 返回bool类型；
bs.all();
// flip 传参数时，用于将参数位取反，本行代码将foo下标２处"反转"，即０变１，１变０
bs.flip(2);
// flip函数不指定参数时，将bitset每一位全部取反
bs.flip();
// set函数不指定参数时，将bitset的每一位全部置为１
bs.set();
// set函数指定两位参数时，将第一参数位的元素置为第二参数的值，本行对foo的操作相当于foo[3]=0
bs.set(3,0);
// set函数只有一个参数时，将参数下标处置为１
bs.set(3);
// reset函数传一个参数时将参数下标处置为０
bs.reset(3);
// reset函数不传参数时将bitset的每一位全部置
为０
bs.reset();
// 将 bitset 转换成 string 类型
string s = bs.to_string();　　
//将 bs 转换成 unsigned long 类型
unsigned long a = bs.to_ulong();　　
//将 bs 转换成 unsigned long long 类型
unsigned long long b = bs.to_ullong();　　

题：求子集

int main() {
    int n;
    cin >> n;
    for (long long i = 0; i < (1 << n); i++) {
        cout << i << ":";
        for (long long j = 0; j < n; j++) {
            if (i & (1 << j)) { cout << " " << j;}
        }
        cout << endl;
    }
}

一对值组合

需要#include
pair<> p 将两个元素组合成一个。

// 构造
pair<T1, T2> p;
pair<T1, T2> p(t1, t2);
make_pair(t1, t2); // 以t1, t2的值创建pair对象。在函数需要返回两个值时，可以使用改函数。返回pair。
// 可以用tie获取其返回值。
int a, b;
tie(a, b) = make_pair(t1,t2);
cout << a << " " << b;
// 访问
cout << p.first << " " << p.second;

元素求和

需要#include
accmulate函数,返回求和之后的值。
在字符串相加时不能使用空串“”作为初值。编译器会认定“”为const char*类型

vector<int> arr;
int sum = accumlate(arr.begint(), arr.end(),0); // 第三个形参为累加的初值。

-Top

Algorithm

以下均需要#include

集合运算

交集：set_intersection()
并集：set_union()
差集：set_difference()
对称差：set_symmetric_difference()

// 方法均为：
(s1.begin(), s1.end(), s2.bigin(), s2.end(), inserter(s3, s3.begin()));

二分查找

upper_bound()和lower_bound()函数。前者返回第一个大于k的元素的地址，后者返回第一个大于等于k的元素的地址。可用于大多数STL如set，map
特别注意：举例在一个升序的容器里，如果所有元素都大于i则，up和low都返回begin。都小于i则返回end（越界了）。
iterator lower_bound( const key_type &key ): 返回一个迭代器，指向键值>= key的第一个元素。
iterator upper_bound( const key_type &key ):返回一个迭代器，指向键值<=key的最后一个元素的后一个元素。
★降序排列的容器：
iterator lower_bound( const key_type &key ): 返回一个迭代器，指向键值<= key的第一个元素。
iterator upper_bound( const key_type &key ):返回一个迭代器，指向键值>=key的最后一个元素的后一个元素。²

int a[n];
int k;
// 注意这里必须减去a,即数组的首地址，才能得到目标元素的下标；
// lower_bound()同；
cout << a[(upper_bound(a, a + n, k)-a)] << endl;
// lower_bound()的大于等于特性可以用来做很多事情；

排列

next_permutaion(), prev_permutaion()函数。将区间内元素的排列顺序变为按字典序(或指定顺序)增大、减小的排列。返回ture或者false。将会改变原有序列！！
is_permutation函数。判断当前序列是否为指定序列的排列情况之一。返回ture或者false。

vector<int> v;
// cmp；
// prev同；
while (next_permutation(v.begin(), v.end()), cmp) {
	cout << v... << endl;
} 
// is_premutation()；
// true 表示v1是v2的一种排列， false 不是；
// 若v2元素数量比v1多，不影响结果。若v2元素数量比v1少，则会产生错误；
vector<int> v1, v2;
is_premutation(v1.begin(), v1.end(), v2.begin());

排序

sort()函数，对区间内元素（不包含last）进行排序，无返回值。

vector<int> v;
// sort排序默认升序
sort(v.begin(), v.end());
// 利用cmp进行排序
// cmp含义：返回true时，把a对应的实参放到b对应的实参前。
bool cmp(int a, int b) {return a > b;}
sort(v.begin(), v.end(), cmp);

删除

erase()函数，删除区间内的元素。返回指向被删除元素后的迭代器/指针。

vector<int> v;
// pos：位置；n：从pos开始连续的元素数量
v.erase(pos, n);
// 范围内删除
v.erase(v.begin()+b, v.begin()+e);
// pos:（string类型的迭代器），删除某个字符
v.erase(pos);

去重

unique()伪去重函数，会把重复且相邻的元素移到末尾，而非删除。返回被删除元素的首地址。

vector<int> v;
v.sort(v.bigin(), v.end());
// 伪去重（此时末尾未重复元素）
v.unique(v.begin(), v.end());
// 真实去重（重复元素被删除）
v.erase(v.unique(v.begin(), v.end()), v.end());

旋转

旋转可以这样想：从f到l元素为一串镯子，经过逆时针旋转操作后，m将会在原来f所在的位置。
rotata()函数，旋转区间内的元素。无返回值。

vector<int> v;
int f, m, l;
rotate(v.begin()+f, v.begin()+m, v.begin()+l);

图1. 何为旋转³

反转

reverse()函数，反转区间内范围的顺序，但不包括last指向的元素。无返回值。

// vector
vector<int> v;
reverse(v.begin(), v.end());
string str;
reverse(str.begin(), str.end());

求范围内最大/小值(数组也可)

max_element()或者min_element()函数。二者返回迭代器/指针。

// vector
vector<int> v;
int maxx = *max_element(v.begin(), v.end());
int minn = *min_element(v.begin(), v.end());
// 数组
int a[6];
int maxx = *max_element(a, a + 6);
int minn = *min_element(a, a + 6);

统计数量

count()函数。返回区间内被统计元素出现的次数。

// vector
vector<int> v;
int b, e;
int cnt = count(v.begin()+b, v.begin()+e, 1); // 第三个形参为被统计的元素。
// 数组
int arr[n];
int b, e;
int cnt = count(arr+b, arr+e, 1);

-Top

Set

multiset

可以有重复元素的集合。

-Top

Vector

emplace

emplace_front, emplace, emplace_back将在vector的内存空间中直接构造元素。用法同push_front, insert, push_back。同样可用于deque和list。
-Top

Deque

双向队列.
-Top

List

双向链表.

合并两个链表

需要头文件#include
splice()函数，无返回值。

int n = 5;
list<int> q(n);
int t = 0, s = 1;
auto it = q[t].begin(); //表示插入位置。
q[t].splice(it, q[s]); // 将q[s]插入到q[t]的it之后，操作之后q[s]为空且it失效。

-Top

Priority_queue

优先队列。top()值恒为最大/最小值。

// 大顶堆（默认情况）
priority_queue<int> q;
// 为降序序列，相当于：
priority_queue<int, vector<int>, less<int> > q;
// 小顶堆,升序序列
priority_queue<int， vector<int>, greater<int> >q;

-Top

Map

形成key与value一对一的映射关系。默认按value自动排序。

multimap

可含有重复key的map。

1 无 $[]$ 操作；
2 $key$和$value$为一对多的关系；

需要输出某个key所对应的所有value时，可以使用二分。

multimap<int,int> mp;
int l;
auto it1 = mp.lower_bound(l);
auto it2 = mp.upper_bound(l);
while (it1!=it2) {
	cout << it1->second << endl;
	it1++;
}

插入元素

map<int, int> mp;
// 在已有原来的key的基础上，第一种方法无法插入，第二种将覆盖原有value
// 按pair格式插入
mp.insert(pair<int,int>(1,2));
mp.insert(map<int,int>::value_type(1,2));
// 按数组格式插入(mp[first] = second;)
mp[1] = 2;

遍历

map<int, int> mp;
auto it = mp.begin();
while (it != mp.end()) {
	cout << it->first << " " << it->second << endl;
}

-Top

参考资料

---

1. 原文链接：
   https://www.cnblogs.com/magisk/p/8809922.html ↩︎

2. 原文链接：https://blog.csdn.net/naipp/article/details/52915573 ↩︎

3. 原文链接：
   http://c.biancheng.net/view/609.html ↩︎