C++ STL学习笔记（到string）

参考书籍：《算法笔记》

STL：

STL，英文全称 standard template library，中文可译为标准模板库，其中封装了很多相当实用的容器，对于程序的简化有着显著的效果。

STL容器：

容器即用来存储并管理某类对象的集合，为满足程序的各种需求，STL 准备了多种容器类型，容器可以是 arrays 或是 linked lists，或者每个元素有特别的键值。STL 包含诸多容器类。容器类是可以包含其他对象的类，就像数组和队列堆栈等数据结构包含整数、小数、类等数据成员一样。STL 可以包含常见的向量类、链表类、双向队列类、集合类、图类等，每个类都是一种模板，这些模板可以包含各种类型的对象。

目前，STL 中使用的主要八种容器如下：

• vector <T>：一种向量。
• queue <T>：一种队列容器，完成了标准 C++ 数据结构中队列的所有功能。
• priority_queue <T>：一种按值排序的队列容器。
• deque <T>：双端队列容器，完成了标准 C++ 数据结构中栈的所有功能。
• set <T>：一种集合容器。
• multiset <T>：一种允许出现重复元素的集合容器。
• map <key, val>：一种关联数组容器。
• multimap <key, val>：一种允许出现重复 key 值的关联数组容器。

vector：

vector可以理解为变长数组。vector支持随机访问，即对于0≤i<n的下标，可以像数组一样用[i]进行取值，但他不是链表，不支持在任意位置O(1)插入，元素的增删一般在末位进行。
vector可以当数组用，还能节约空间。

定义：

#include<vector>
vector<int> a;	//相当于一个长度动态变化的int数组
vector<int> b[233];	//相当于第一维长度233，第二维长度动态变化的数组

struct rec{…};
vector<rec> c;	//自定义的结构体也可以保存在vector中

vector<vector<int>> name;	//>>需要加上空格

vector<int> vi[100];	//一维长度固定，二维长度可变

vector<int> a(10); //定义了10个整型元素的向量，但没有给出初值，其值是不确定的。
vector<int> a(10,1); //定义了10个整型元素的向量,且给出每个元素的初值为1
vector<int> a(b); //用b向量来创建a向量，整体复制性赋值
vector<int> a(b.begin(),b.begin+3); //定义了a值为b中第0个到第2个（共3个）元素

int b[7]={1,2,3,4,5,9,8};
vector<int> a(b,b+7); //从数组中获得初值

vector（int nSize）：创建一个vector，元素个数为nSize。
vector（int nSize， const T& t）：创建一个vector，元素个数为nSize，且值均为t。

size() 和 empty() (所有STL容器都支持):

size()返回vector的实际长度（包含元素的个数），empty()返回一个bool类型，判断vector是否为空。两者的时间复杂度都是O(1)。

reserve() 和 resize()：

• reserve() 是容器预留空间，但在空间内不真正创建元素对象，所以在没有添加新的对象之前，不能引用容器内的元素。加入新的元素时，要调用push_back()/insert()函数。

• resize() 是改变容器的大小，且在创建对象，因此，调用这个函数之后，就可以引用容器内的对象了，因此当加入新的元素时，用[]操作符，或者用迭代器来引用元素对象。此时再调用push_back()函数，是加在这个新的空间后面的。

vector<int> v;
v.reserve( 100 );     // 新元素还没有构造, 此时不能用[]访问元素
for (int i = 0; i < 100; i++ ) 
     v.push_back( i ); //新元素这时才构造

v.resize( 102 );      // 用元素的默认构造函数构造了两个新的元素
v[100] = 1;           //直接操作新元素
v[101] = 2;  

clear()：

用于清空vector，时间复杂度为O(n)。

迭代器：

迭代器就像STL容器的“指针”，可以用*操作符解除引用。

一个保存int的vector的迭代器声明方法为：vector\<int>::iterator it;

vector的迭代器是“随机访问迭代器”，可以把vector的迭代器与一个整数相加减，行为和指针的移动类似。可以把vector的两个迭代器相减，结果与指针相减类似，得到两个迭代器对应的下标之间的距离。

begin()/end():

begin()取首元素地址，返回指向vector中的第一个元素的迭代器，例如a是一个非空的vector。a[i]和*(a.begin()+i)等价。

所有的容器都可视作一个“左闭右开”的结构，end()取尾元素地址的下一个地址，即第n个元素再往后的“边界”。*a.end()与a[n]都是越界访问，其中n = a.size()。

下面两份代码都遍历了vector<int> a，并输出所有元素：

for(int i = 0;i < a.size();i ++ )
	cout << a[i] << endl;

//迭代器不支持it < a.end()写法
for(vector<int>::iterator it = a.begin(); it != a.end(); it ++ )
	cout << *it << endl;

注意：在常用STL容器中，只有vector和string才能使用a.begin() + 3这种迭代器加上整数的写法。

front() 和 back():

• front()： 返回vector的第一个元素，等价于*a.begin()和a[0]。
• back()： 返回vector的最后一个元素，等价于*--a.end()和a[a.size()-1]。

push_back()/emplace_back 和 pop_back()：

• a.push_back(x)：把元素x插入到vector a的尾部。
• a.emplace_back(x)：c++11新增。push_back首先会创建这个元素，然后再将这个元素拷贝或者移动到容器中（如果是拷贝的话，事后会自行销毁先前创建的这个元素）；而 emplace_back() 在实现时，则是直接在容器尾部创建这个元素，省去了拷贝或移动元素的过程。
  因此emplace_back() 的执行效率比 push_back() 高
• a.pop_back()：删除vector a的最后一个元素。

insert():

insert(it, x)：用来向vector的任意迭代器it处插入一个元素x，时间复杂度O(n)。

#include <iostream>
#include <vector>
using namespace std;

int main(){
    vector<int> a;
    for(int i = 1; i <= 5; i ++ ){
        a.push_back(i);
    }
    for(int i = 0; i < a.size(); i ++ ){
        cout << a[i] << ' ';    //结果1 2 3 4 5 
    }
    cout << endl;
    
    a.insert(a.begin() + 2, -1);
    
    for(int i = 0; i < a.size(); i ++ ){
        cout << a[i] << ' ';    //结果1 2 -1 3 4 5 
    }
    
    return 0;
}

erase():

有两种用法：删除单个元素、删除一个区间内的所有元素。
erase(it)：删除迭代器为it处的元素
erase(first, last)：删除[first, last)内的所有元素。
因此a.erase(a.begin(), a.end())效果等于a.clear()

用vector代替邻接表保存有向图：

const int MAX_EDGES = 100010;
vector<int> ver[MAX_EDGES], edge[MAX_EDGES];

//保存从x到y权值为z的有向边
void add(int x,int y,int z){
    ver[x].push_back(y);
    edge[x].push_back(z);
}

//遍历从x出发的所有有向边
for(int i = 0;i < ver[x].size();i++){
    int y = ver[x][i],z = edge[x][i];
    //有向边（x,y,z）
}

---

set:

set翻译为集合，是一个内部自动有序且不含重复元素的容器。
主要作用是自动去重并按升序排序。
如果要处理元素不唯一的情况，使用multiset，要只去重但不排序用unordered_set
定义：

set<int> name;
set<node> name;	//node是结构体类型

set<int> a[100]; //a[0]~a[99]中的每一个都是一个set容器

set容器内元素的访问：

set<int>::iterator it;	//set只能使用迭代器，通过*it访问

枚举set中的元素：

#include <iostream>
#include <set>
using namespace std;

int main(){
    set<int> a;
    
    a.insert(2);
    a.insert(1);
    a.insert(2);
    a.insert(5);
    a.insert(2);
    
    //不支持it < a.end()的写法
    for(set<int>::iterator it = a.begin(); it != a.end(); it ++ ){
        printf("%d ",*it);	//结果1 2 5 
    }
    
    return 0;
}

insert()：插入
find():find(value)返回set中对应值为value的迭代器，查找失败返回end()的值。

set<int>::iterator it = a.find(2);
printf("%d\n", *it);	//在set中查找2，返回其迭代器

erase()：删除单个元素、删除一个区间内的函数
size()：获得set内元素的个数
clear()：清空set中的所有元素

---

string:

使用string需要加上string头文件#include <string>(注意string.h和string不同)
定义：

string str = "acdc";

string中内容的访问：
通过下标：

string str = "acdc"
for(int i = 0; i < str.length(); i ++ ){
	printf("%c", str[i]);
}

cout << str;

printf("%s\n", str.c_str());

输入和输出整个字符串：只能使用cin和cout
或者使用c_str()把string转换为字符数组，用printf输出.
也可以通过迭代器用*it来访问string中的每一位。

string常用函数：
可以用+将两个string拼接；
两个string可以直接用=、 != 、>、 <进行比较，规则是字典序；
length()返回string的长度（即存放的字符数），size()和length()基本相同；
insert(pos, string)：在pos位置上插入字符串string；
insert(it, it2, it3):it为原字符串的欲插入位置，it2和it3为待插入字符串的首位迭代器，串[it2，it3)将被插入到it位置上；
earse(it)：删除单个字符；
earse(pos, length)：删除从pos开始的length个字符；
clear()：清空string
substr(pos, length)：返回从pos开始的length个字符
string::npos：是一个常数，值为-1或者4294967295，用做find()失配时的返回值；
str.find(str2)：当str2是str的子串时返回其在str中第一次出现的位置，否则返回string::npos
str.replace(pos, len, str2):把str从pos开始长度为len的子串替换为str2
str.replace(it1, it2, str2):把str的迭代器[it1，it2)范围的子串替换为str2

---

priority_queue:

优先队列，底层是用堆(heap)来实现的。优先队列中队首元素一定是优先级最高的那个。往堆中push元素，底层的堆会随时调整，保证队首元素是优先级最大的。

定义一个优先队列：

#include <queue>
using namespace std;

priority_queue <typename> name;

基本操作

和队列不同，优先队列没有front()和back()函数，只能通过top()函数来访问队首元素。

push(x): x入队，时间复杂度O(logN)， N为当前优先队列中的元素个数

top(): 获取队首元素，时间复杂度O(1)

pop: 队首元素出队，事假复杂度O(logN) , N为当前优先队列中的元素个数

empty(): 检查优先队列是否为空，为空返回true

size(): 返回优先队列内元素的个数

优先队列内元素的优先级的设置

基本数据类型的优先级设置：（默认为数字大的优先级高）

priority_queue<int> q;	//默认数字大的优先级高
priority_queue<int, vector<int>, less<int>> q;	//less<int> 数字大的优先级高
priority_queue<int, vector<int>, greater<int>> q;	//greater<int> 数字小的优先级高

常见用途

优先队列可以解决一些贪心的问题，也可以对Dijkstra算法进行优化。
注意：使用top()函数之前需要用empty()判断是否为空，否则可能因为队空而报错。

---

算法：

STL 提供了非常多的数据结构算法。这些算法在命名空间 std 的范围内定义，通过包含头文件 <algorithm> 来获得使用权。
常见的部分算法如下：

• for_each()；
• find()；
• find_if()；
• count()；
• count_if()；
• replace()；
• replace_if()；
• copy()；
• unique_copy()；
• sort()；
• equal_range()；
• merge()；