ACM学习之路

北京理工大学ACM冬季培训课程

因为是马上大一结束了，只学习了C语言，对于前几天参加的蓝桥杯省赛是给我打得找不到北，发现自己如果想真的走这条路就应该有信心走下去。

今天看了北京理工大学ACM冬季培训课程，开始尝试通过csdn来保存自己的学习进度。

目录

C++STL

C++语法特性

C++标准库

---

C++STL

C++语法特性

1. bool
    C++添加了新的两个基本类型bool，有true和false两个值，逻辑中用true来代替非0，false来代替0能有效提高程序可读性
    bool yes = true
    if ( yes )
    {
        puts("yes");
    }
    else
    {
        puts("no");
    }

2.动态开辟内存
    与C中的malloc类似，C++中用new来动态开辟内存。
    new写起来会更加简明一些。
    C++不支持变长数组。
    int* number = new int;
    int* arr = new int[100];
    int* arr= (int*)malloc(100 * sizeof(int));

3.引用
    C++中用&来创建引用。可以把引用当成一个不能改变指向对象的指针。
    引用多数情况在函数传参数的时候才会用到，以简化指针的代码。
    void swap(int &a, int& b){
        int c = a;
        a = b;
        b = c;
    }
    int main() {
        int a=1,b=2;
        swap(a,b);
        cout << a << endl <<  b;
        return 0;
    }

4.函数重载
    C++中，函数是以函数名+参数列表来区分的
    也就是说，两个函数可以名字相同，但参数列表和返回值不同
    函数的部分参数可以缺省，没有提供参数时用缺省值来替代
    int add(int a, int b)
    {
        return a + b;
    }
    int add(int a)
    {
        return a;
    }
    int minus(int a. int b =0)
    {
        return a - b;
    }
    int main()
    {
        add(0);
        add(0, 0);
        minus(0);
        minus(0, 0)
        return 0;
    }

5.struct
    结构不用再和C语言里面一样前面加个struct了，可以直接使用结构的名字
    struct node
    {
        int number;
        node* next;
    };
    node* head;

    struct中可以加入与结构同名，无返回值的构造函数。在创建struct的时候会自动调用构造函数。
    与缺省参数配合使用会让代码更简洁。
    struct nude
    {
        int number;
        node* next;
        node(int _number = 0, node* = NULL)
        {
            number = _number;
            next = _next;
        }
    };
    int main()
    {
        node a = node(0);
        node* b = new node(1, &a);

C++标准库

重点：<vector> <string> <algorithm>
以后：<queue> <stack> <set> <map> <bitset> <functional> <complex>

<cstring>
char str[10]
strlen() 字符串长度 eg:strlen(str)
strcmp() 字符串比较
strcpy() 字符串拷贝
memset() 暴力清空 eg: memset(str, 0, sizeof(str))
memcpy() 暴力拷贝

<cmath>
三角函数、指数函数、浮点数取整

<cstdlib>
qsort() C语言快排
rand() 随机数
malloc() free() C语言动态分配内存

<ctime>
time(0) 从1970年到现在的秒数(配合随机数)
clock() 程序启动到目前位置的毫秒数

<cctype>
isdigit() 判断字符是否是数字
isalpha() 判断字符是否为大小写字母

<vector>数组
    vector可以呗堪称一个超级数组
    它既可以和C语言的数组一样用下标访问，也可以像链表一样动态改变长度
    vector<int> arr1(100)
    int arr2[100];

    vector<int> list;
    list.push_back(1);
    list.push_back(2);
    list.push_back(3);
    list.push_back(4);

    vector的遍历

    vector<int> arr(100);
    vector<int> list;
    for (int i = 0; i < 100; i++)
    {
        scanf("%d", &arr[i]);
        cout << arr[i] << endl;
    }
    for(int i = 0; i < 100; i++)
    {
        int a;
        cin >> a;
        list.push_back(a);
        printf("%d\n", list[i]);
    }

    与普通的数组类似，vector也可以用指针来访问遍历每一个元素，STL中的指针被称为”迭代器“
    vector<int> arr1(100);
    int arr2[100];
    vector<int>::iterator p1;
    int* p2;

    迭代器与普通指针使用方法对比
    vector<int> arr1(100);
    int arr2[100];
    vector<int>::iterator p1;
    int* p2;
    for (p1 = arr1.begin(); p1 != arr1.end(); p1++)
    {
        cout << *p1 << endl;
    }
    int i;
    for (p2 = arr2, i = 0; i < 100; i++, p2++)
    {
        cout << *p2 << endl;
    }

    list.size();数组元素个数
    list.clear();一键清空数组
    list.empty();数组是否为空
    list.begin();数组的首元素迭代器
    list.end();数组最后一个元素的下一个元素的迭代器
               该元素实际在数组中不存在
    list.erase(p1);删除数组某个迭代器所在位置的数字
    list.push_back(1);忘数组后面添加元素
    list.pop_back();删除数组最后一个元素

<string>字符串
    字符串string可以看成一个特殊的vector
    string和c语言字符串的关系就和vector和普通数组的关系一样
    string str1 = "Hello";
    char str2[] = "world";
    string str2;
    str2.push_back('!');
    cout << str1 << " " << str2 << str3 << endl;  // Hello world!

    vector有的操作string基本都有，唯一区别是size的复杂度
    所有参数为字符串的地方既可以是string也可以是C字符串
    string str = "hello";
    str.length(); str.size(); // 0(n)
    str.insert(1, "aaa"); // 在下标为1处插入一个字符或字符串 O(1)
    str.insert(str.begin(), "a") // 在迭代器处插入一个字符或字符串 O(n)
    str.c_str(); // 返回C语言字符串，用于printf O(n)
    str.append(str2); // 把str2拼接到str后面
    str.compare(str2); // strcmp(str, str2)
    str == str2; // strcmp(str, str2) == 0;
    str += str2; // str.append(str2);
    str == 'a' // str.push_back('a');

<algorithm>
    algorithm和之前两个头文件不同，它没有定义什么新类型，而是定义了很多使用的算法，极大简化了代码量。
    sort快速排序
    int arr[] = {2, 3, 1, 5, 4};
    int n = 5;
    sort(arr, arr + n); // 参数 排序开始的指针 排序结束的指针（最后一个元素的下一个元素的指针）
    for ( int i = 0; i < n; i++)
    {
        printf("%d\n",arr[i]);
    }

    vector<int> arr;
    arr.push_back(1);
    arr.push_back(6);
    arr.push_back(0);
    sort(arr.begin(),arr.end());
    for (int i = 0; i < arr.size(); i++){
        printf("%d\n",arr[i]);
    }
    for (vector<int>::iterator it = arr.begin(); it < arr.end(); it++){
        printf("%d\n",*it);
    }

    和C语言qsort一样，sort可以使用自定义比较函数
    比较函数参数是两个待比较变量，返回值是比较的bool值
    内部排序函数是按小于关系来的，排序结果是升序
    如果像上图一样按大于关系比较，则可以得到降序的排序结果
    bool cmp(int a, int b){
        return a > b;
    }
    int main() {
    vector<int> arr;
    arr.push_back(1);
    arr.push_back(6);
    arr.push_back(0);
    sort(arr.begin(),arr.end(), cmp);
    for (vector<int>::iterator it = arr.begin(); it < arr.end(); it++){
        printf("%d\n",*it);
    }

    自己定义的结构体一定要自己写比较函数
    比较函数是比较一个点的x坐标，x坐标相同的情况下比较y坐标
    struct Point{
        int x, y;
    };
    Point points[1111];
    bool cmp(Point a, Point b){
        if(a.x != b.x){
            return a.x < b.x;
        }
        return a.y < b.y;
    }
    int main(){
        sort(points, points + 10, cmp);
    }

    min(1, 2); max(1, 2); // 最大最小值 O(1)
    min_element(arr.begin(), arr.end()); // 数组最小指针
    max_element(arr.begin(), arr.end()); // 数组最大指针
    nth_element(arr.begin(), arr.begin() + n, arr.end()); // 把数组第n校（从0开始算）的数放到第n个位置，类似快排，并保证它的左边的数比
    它小，右边的数比它答

    swap(arr[0], arr[1]); // 交换任意两个同类型的变量
    reverse(arr.begin(), arr.end()); // 反转数组
    int newLength = unique(arr.begin(), arr.end() - arr.begin()); // 是arr中不出现重复的数字 返回取出后数组的结束指针

    lower_bound一般被用来二分查找
    bool isExist = binary_search(arr.begin(), arr.end(), 1); // 查找对应元素是否存在
    // 两个函数都是在做同一件事情
    // 如果把一个数插入有序数组，它应该插入在哪个位置
    // lower_bound返回第一个插入位置的指针，upper_bound返回最后一个位置的指针
    int firstLoc = lower_bound(arr.begin(), arr.end(), 2) - arr.
begin();
    int lastLoc = upper_bound(arr.begin(), arr.end(), 2) - arr.begin();