因为太久没用 C++了，导致很多细节的语法已经记不得了。借着这一次刷的少量题回顾一下 C++的语法，以后总会有时候能用上的。

String

1
2
3
4
5
#include<string>
s.find(s1);  //找到第一个出现的s1
s.substr(pos, n);  //截取从pos开始的n个字符
s.substr(pos);     //截取从pos开始的所有字符
s.replace(pos, n , s1); //将s从pos开始的n个字符替换为s1

Vector

1
#include<vector>

初始化

语法 含义
vector<int> v1 默认为空的 vector
vector<int> v1(v2) 默认 v2 副本的 v1
vector<int> v1(n, i) 默认内容为 n 个元素 i
vector<int> v1(n) 默认内容为 n 个默认元素，以 int 为例，应是构建了包含 n 个 0 的 vector

Vector的基本操作

1
2
3
4
vector<int> test;
test.push_back(1); // 插入新元素
test.size();        // 返回长度
test.erase(test.begin()+2); // 删除第3个元素（下标为2的元素）。但这个操作很慢，不建议

Vector 的迭代器访问

1
2
3
4
vector<int> test;
vector<int>::iterator it;
for(it=test.begin();it!=test.end();it++)
    cout<<*it<<endl;

算法

1
2
3
#include<algorithm>
reverse(test.begin(), test.end());  //颠倒
sort(test.begin(), test.end()); //升序排序

*为了降序排序

1
2
3
4
5
6
bool Comp(const int &a,const int &b)
{
    return a>b;
}

sort(test.begin(),test.end(),Comp);

需要定义一个特殊的比较函数，比较函数的输入为 vector 内含有的元素。对于结构体，可以使用类似的方法定义.

*当插入对象是数组时

1
2
3
4
5
6
7
8
9
10
11
12
#include <iostream>   
using namespace std;  
int main()  
{  
    int out[3][2] = { 1, 2,   
             3, 4,  
            5, 6 };  
    vector <int*> v1;  
    v1.push_back(out[0]);  
    cout << v1[0][0] << endl;  //1  
    return 0;  
}

Pair

在进入 Map 之前我们需要先搞定 Pair 类。

1
2
3
4
pair<int, int> test;
pair<int, int> test(1, 2);
cout<<test.first<<endl>>;
cout<<test.second<<endl>>;  //对pair元素的访问

Map

类似 python 的字典（不过灵活度大幅度下降。）

1
#include<map>

初始化

1
2
map<int, int> map_int;
map<int, string> map_string;

其馀的初始化方法和 Vector 雷同，故不赘述。

Map的基本操作

1
2
3
4
map<int, int> test;
test.insert(pair<int,int>(1,2));  //插入新元素，使用该方法插入已经存在的键时会报错
test[1] = 2; //该方法结果和上条效果相同；不存在该键的情况下会新建，反之会覆盖
test.size(); //字典的大小

查找/读值

1
2
3
4
l_it=test.find(1); //查找元素，返回一个迭代器；若迭代器指向map的末尾，则不存在该元素
if(l_it==test.end())
    cout<<"we do not find 112"<<endl;
else cout<<l_it->second<<endl; //由于返回的对象是一个迭代器，而迭代器指向的是一个Pair类型，故可以通过Pair类型的访问方法访问

遍历

1
2
3
4
5
map<int, int>::iterator it;
for (it = mp.begin(); it != mp.end(); it++){
        printf("%d->%d\n", it->first, it->second);
}
return 0;

删除

1
2
mp.erase(k)	;//删除某一个键
mp.erase(it);//删除迭代器指向对象

unordered_map

效果和 map 非常相似，但是一般情况下，使用 unordered_map 更快。

1
#include<unordered_map>

Stack & Queue

Stack

1
2
3
4
5
6
7
#include<stack>
stack<int> s;
s.size();
s.empty(); //判断是否为空
s.pop();   //弹出栈顶元素但不返回
s.top();   //返回栈顶元素
s.push();  // 加入新元素

Queue

1
2
3
4
5
6
7
8
#include<queue>
queue<int> q;
q.empty(); //如果队列为空返回true，否则返回false
q.size(); //返回队列中元素的个数
q.pop();  //删除队列首元素但不返回其值
q.front(); //返回队首元素的值，但不删除该元素
q.push(); //在队尾压入新元素
q.back(); //返回队列尾元素的值，但不删除该元素

Priority_queue

1
2
3
#include<queue>
priority_queue<int> pq;  //默认是最大堆
priority_queue<int, vector<int>, greater<int> > pq; //最小堆

其馀操作如同普通的 queue。

自定义数据结构

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
#include <iostream>
#include <queue>
using namespace std;

//方法1
struct tmp1 //运算符重载<
{
    int x;
    tmp1(int a) {x = a;}
    bool operator<(const tmp1& a) const
    {
        return x < a.x; //大顶堆
    }
};

//方法2
struct tmp2 //重写仿函数
{
    bool operator() (tmp1 a, tmp1 b) 
    {
        return a.x < b.x; //大顶堆
    }
};

int main() 
{
    tmp1 a(1);
    tmp1 b(2);
    tmp1 c(3);
    priority_queue<tmp1> d;
    d.push(b);
    d.push(c);
    d.push(a);
    while (!d.empty()) 
    {
        cout << d.top().x << '\n';
        d.pop();
    }
    cout << endl;

    priority_queue<tmp1, vector<tmp1>, tmp2> f;
    f.push(c);
    f.push(b);
    f.push(a);
    while (!f.empty()) 
    {
        cout << f.top().x << '\n';
        f.pop();
    }
}

这里主要使用第一种方法吧：在数据结构重载运算符。