ACM常用的C++ && STL

内容

1. c++输入输出
2. c++ string
3. vector:不定长数组
   
4. map:映射
5. queue:队列
6. sort:排序
7. priority_queue:优先队列

c++输入输出

#include <iostream>    //c++输入输出的头文件
using namespace std;   //名称空间, 不懂死记硬背

int main(){
    int a;  //或是long long a; double a; char a[10]; 等等，总之不需要像c语言一样要占位符
    cin >> a;  //输入
    cout << a; //输出

    cout << "abcdefg";  //输出字符串
    cout << endl; //换行
    cout << "abcdefg" << endl; //合并cout，效果和上面两个语句一样

    int b;
    cin >> a >> b;  //合并cin，效果和 cin >> a;  cin >> b; 一样
    cout << "abcdefg
"; //效果和上一个语句一样
    cout << 'a'; //输出字母a，而不是ASCII码，这个和c语言有点不一样
    
    return 0;
}

在这里我们可以看到，用c++输入输出能够极大方面减少错误率，而且支持的对象也非常多(把上面的int a改成double a / long long a等等都是可以的)，c语言的输入输出实在是有点麻烦。不过c语言的输入输出优点也是有的：格式化输出 printf(); 更方便，而且效率更高(比c++的输入输出要快)。所以，一般情况可以直接用c++的输入输出，而对于数据输入量大的题目最好改成c语言的输入输出。另外，如果想在c++中用c的头文件，只需要把 #include <xxx.h> 改成 #include <cxxx> 。举个例子，c语言中的输入输出头文件是 #include <stdio.h>，那么在c++中就是 #include <cstdio>。

c++ string

string类：这个就是升级版的 char s[] 。顾名思义，就是字符串，但是这个字符串比 char s[] 方便很多。我们先来看看string的头文件和名称空间：

#include <string>
using namespace std;

是不是又看到了 using namespace std; ，这个几乎是每个头文件的通用名称空间，其他的c++头文件默认也是这个名称空间，而且还可以这样写：

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

以后写完一堆头文件后直接在末尾加一句 using namespace std; 就行了。

string的用法：

#include <iostream>    
#include <cstdio>
#include <string>
using namespace std;   

int main(){
    string s;
    cin >> s; //输入
    cout << s; //输出

    string s2;
    s2 = s;   //把s里面的内容复制到s2里面

    string s3;
    s3 = s + s2; //拼接s和s2然后复制到s3里面
    s = s + s2; //把s2拼接到s末尾

    int len = s.length(); //计算s的长度, 然后赋值到len，功能和strlen()一样，都不算''

    if(s[0] != 'a') s[0] = 'a'; //可以直接像char s[]一样访问和修改

    int cnt = 0;
    if(s == s2) cnt++;  //可以直接比较s和s2是否相等

    return 0;
}

vector:不定长数组

#include <cstdio>
#include <iostream>
#include <vector>     //相关头文件
using namespace std;

int main(){
    //vector(不定长数组)用法介绍
    vector<int> G;     //创建vector
    G.push_back(5);    //加入元素5, 类似于栈
    G.push_back(3);    //加入元素3
    G.push_back(7);    //加入元素7
    //这时vector里面有元素: 5, 3, 7

    //访问
    int a;
    a = G[0];   //a被赋值为vector里面的第一个元素，即a = 5
    a = G[1];   //a被赋值为vector里面的第二个元素，即a = 3

    //获得vector的大小: G.size()    //这里是遍历vector里面的元素
    for(int i = 0; i < G.size(); i++){
        printf("%d
", G[i]);
        //这里G.size() == 3, 所以输出G[0], G[1], G[2]
    }
    printf("
");

    G.clear(); //清空不定长数组G, 相当于不定长数组大小设为0

    //高级用法: vector数组
    vector<int> g[3];
    //这里创建了3个vector, 其中分别是g[0], g[1], g[2]
    g[1].push_back(4);   //向g[1]这个vector加入元素4
    g[1].push_back(1);   //向g[1]这个vector加入元素1

    //访问
    a = g[1][0];   //a被赋值为g[1]里面的第一个元素，即a = 4
    a = g[1][1];   //a被赋值为g[1]里面的第二个元素，即a = 1

    for(int i = 0; i < g[1].size(); i++){
        printf("%d
", g[1][i]);
        //这里g[1].size() == 2, 所以输出g[1][0], g[1][1]
    }

    return 0;
}

map:映射

#include <cstdio>
#include <iostream>
#include <map>
#include <string>
using namespace std;

int main(){
    //map用法介绍
    map<string, int> mp;     //创建一个map: 从string到1的映射
    mp["abc"] = 1;   //建立从字符串"abc"到整数1的映射
    string s = "efg";   //创建一个string
    mp[s] = 5;       //建立从字符串"efg"到整数5的映射

    //访问
    int a;
    a = mp["abc"];    //这时mp["abc"]的值为1, 也就是a = 1
    cout << a << endl;
    a = mp[s];        //这时mp[s]的值为5, 也就是a = 5
    cout << a << endl;

    //使用char数组
    char s2[5] = "gsd";
    mp[s2] = 9;       //建立从字符串"gsd"到整数9的映射
    cout << mp[s2] << endl;

    mp.clear();  //清空mp里面的元素, 相当于把所有映射都抹去

    //最后注意的是, 虽然map看起来很像hash, 但其内部实现不是hash, 而是一颗树(红黑树)
    //也就是说, 当进行访问map的操作时, 时间复杂度为O(log m)(m为映射数量), 并不是O(1)

    return 0;
}

queue:队列

#include <cstdio>
#include <iostream>
#include <queue>
using namespace std;

int main(){
    //queue基本用法
    queue<int> q;    //创建一个先进先出的队列(也就是这个队列只能在尾部加入元素, 头部取出元素, 这个是关键)
    q.push(1);    //加入元素1
    q.push(2);    //加入元素2
    q.push(3);    //加入元素3
    //这时队列是: 1, 2, 3

    //访问
    int a;
    a = q.front();  //这时q.front()的值为1, 所以a = 1, 注意这里只是读取队列首元素, 并没有弹出元素
    cout << a << endl;
    a = q.front();
    cout << a << endl;

    //弹出
    q.pop();    //弹出队列的首元素, 也就是变成2, 3
    a = q.front();
    cout << a << endl;

    //判断队列是否为空
    q.pop();    //弹出队列的首元素, 也就是变成3
    q.pop();    //弹出队列的首元素, 此时队列为空
    if(q.empty()) cout << "Yes
";      //如果队列为空, 则q.empty()为真, 则输出"Yes"
    if(q.size() == 0) cout << "Yes
";  //如果队列大小为0, 则输出"Yes"

    return 0;
}

sort:排序

#include <cstdio>
#include <iostream>
#include <algorithm>
using namespace std;
//先从主函数看

struct node{
    int first, second;
};

bool cmp1(int x, int y){
    return x > y;    //从大到小排
}

bool cmp2(int x, int y){
    return x < y;    //从小到大排
}

bool cmp_node(node x, node y){
    if(x.first == y.first) return x.second < y.second;
    else return x.first < y.first;
    //这里的意思: 优先对结构体的第一个值进行排序, 如果第一个值相等, 就按照第二个值进行排序
}

int main(){
    //sort的用法
    int a[5] = {5,4,3,2,1};
    sort(a, a+5);    //默认对数组a进行从小到大排序
    for(int i = 0; i < 5; i++){
        cout << a[i] << " ";
    }
    cout << endl;

    string s[3] = {"bcd", "abc", "a"};
    sort(s, s+3);    //默认对字符串进行字典序排序
    for(int i = 0; i < 3; i++){
        cout << s[i] << endl;
    }
    cout << endl;

    //自定义比较级(比较函数):
    sort(a, a+5, cmp1);  //按cmp1的比较级排序, 注意这里cmp1后面不能加()
    for(int i = 0; i < 5; i++){
        cout << a[i] << " ";
    }
    cout << endl;

    sort(a, a+5, cmp2);   //按cmp2的比较级排序
    for(int i = 0; i < 5; i++){
        cout << a[i] << " ";
    }
    cout << endl;

    cout << endl;
    //对结构体进行排序
    node G[3] = {{5,3}, {5, 2}, {1, 9}};
    sort(G, G+3, cmp_node);   //按照cmp_node进行排序
    for(int i = 0; i < 3; i++){
        printf("G[%d]: %d %d
", i, G[i].first, G[i].second);
    }
    cout << endl;

    return 0;
}

priority_queue:优先队列

#include <cstdio>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
//从主函数看起

struct node{
    int first, second;
};

struct cmp1{    //这里比较级是用结构体, 而不是函数
    bool operator () (int a, int b){   //重载操作, 记住就行
        return a > b;   
        //小的优先在前面, 因为是用"堆"去实现的, 不清楚堆就直接记住和sort的cmp刚好相反
    }
};

struct cmp2{
    bool operator () (node a, node b){
        if(a.first == b.first) return b.second > b.second;
        return a.first > b.first;
    }
};

int main(){
    //priority_queue基本用法
    priority_queue<int> q;  //创建一个优先队列
    q.push(1);    //加入元素1
    q.push(3);    //加入元素3
    q.push(2);    //加入元素2
    
    if(!q.empty()) printf("YES
");    //q.empty():判断优先队列是否为空
    
    int a;
    while(!q.empty()){
        a = q.top();    //这里只是读取队列首元素, 并没有弹出元素
        printf("%d ", a);
        q.pop();        //弹出首元素
    }
    printf("
");
    //运行上面程序，发现输出为:3, 2, 1, 也就是说, 默认优先队列默认从大到小排列
    
    priority_queue<int, vector<int>, less<int> > q_less;
    //创建一个优先级为:从大到小, 排的优先队列
    
    priority_queue<int, vector<int>, greater<int> > q_great;
    //创建一个优先级为:从小到大, 排的优先队列
    
    priority_queue<int, vector<int>, cmp1> q_cmp1;
    //自定义比较级:cmp1
    
    priority_queue<node, vector<node>, cmp1> q_cmp1;
    //自定义比较级:cmp2
    return 0;
}