C++语言涉猎笔记（四）

集合vector

#include <iostream>
#include <vector> // 引入 vector 容器的支持

using namespace std;

int main() {
    //创建一：动态长度的集合
    vector<int> vector1;
    //创建二：长度为10的集合
    vector<int> vector2(10);
    //创建三：长度为10,每个值都为0的集合
    vector<int> vector3(10, 0);

    //集合插入，参数一为迭代器，参数二为插入值
    //vector1.begin()为位置移到最前面的迭代器
    //vector1.end()为位置移到最后面的迭代器
    vector1.insert(vector1.begin(), 40);
    vector1.insert(vector1.begin(), 30);
    vector1.insert(vector1.begin(), 20);
    vector1.insert(vector1.begin(), 10);
    vector1.insert(vector1.end(), 50);
    //vector1.front() 最前面的值
    //vector1.back() 最后面的值
    cout << vector1.front() << endl;
    cout << vector1.back() << endl;
    //直接修改最前面最后面的值
    vector1.front() = 11;
    vector1.back() = 121;
    //erase 移除元素，参数为迭代器
    vector1.erase(vector1.begin());
    //遍历集合一，通过size
    for (int i = 0; i < vector1.size(); ++i) {
        cout << vector1[i] << endl;
    }
    //遍历集合二，通过迭代器
    //vector<int>::iterator 可以简写为auto 自带类型推倒
    for (vector<int>::iterator iterator = vector1.begin(); iterator != vector1.end(); iterator++) {
        cout << *iterator << endl;
    }
    return 0;
}

集合stack(栈)

#include <iostream>
#include <stack>

using namespace std;

int main() {
    stack<int> stack;
    //push添加元素，后添加的在最前面
    stack.push(10);
    stack.push(20);
    stack.push(30);
    stack.push(40);
    //遍历只能通过弹出元素来完成，遍历结束容器就空了
    //empty方法判断栈是否是空的
    while (!stack.empty()) {
        //top方法获取顶层元素的值
        int top = stack.top();
        cout << top << endl;
        //pop把顶层元素弹出栈
        stack.pop();
    }
    return 0;
}

集合queue(队列)

#include <iostream>
#include <queue>

using namespace std;

int main() {
    queue<int> queue;
    //push添加元素，先添加的在最前面
    queue.push(10);
    queue.push(20);
    queue.push(30);
    queue.push(40);
    //front方法获取最前面的值
    //back方法获取最后面的值
    queue.front() = 11;
    queue.back() = 44;
    //遍历只能通过弹出元素来完成，遍历结束容器就空了
    //empty方法判断队列是否是空的
    while (!queue.empty()) {
        //front方法获取顶层元素的值
        int front = queue.front();
        cout << front << endl;
        //pop把第一个元素弹出队列
        queue.pop();
    }
    return 0;
}

集合priority_queue(优先级队列)

#include <iostream>
#include <queue>

using namespace std;

int main() {
    //第二个参数是内部需要一个vector，说明队列是对vector的封装
    //第三个参数是排列方式的结构体 greater<int>从小到大 less<int>从大到小
    priority_queue<int, vector<int>, greater<int>> p;
    //默认从大到小的排列即 priority_queue<int, vector<int>, less<int>>
    priority_queue<int> priorityQueue;
    priorityQueue.push(40);
    priorityQueue.push(20);
    priorityQueue.push(50);
    priorityQueue.push(30);
    priorityQueue.push(10);
    while (!priorityQueue.empty()) {
        //top方法获取顶层元素的值
        int top = priorityQueue.top();
        cout << top << endl;
        priorityQueue.pop();
    }
    return 0;
}

集合list

#include <iostream>
#include <list>

using namespace std;

int main() {
    list<int> list1;
    list<int> list2(10);
    list<int> list3(10, 10);
    //插入最前面
    list1.push_front(10);
    list1.insert(list1.begin(), 10);
    //插入最后面
    list1.push_back(20);
    list1.insert(list1.end(), 20);
    //修改最前面和最后面
    list1.front() = 11;
    list1.back() = 22;
    //删除最前面和最后面
    list1.erase(list1.begin());
//    list1.erase(list1.end());
    list1.pop_back();
    //只能使用迭代器遍历
    for (auto iterator = list1.begin(); iterator != list1.end(); iterator++) {
        cout << *iterator << endl;
    }
    return 0;
}

集合set

#include <iostream>
#include <set>

using namespace std;

int main() {
    //less<int>可省略，默认值，从小到大
    set<int, less<int>> _set;
    _set.insert(10);
    _set.insert(30);
    _set.insert(20);
    _set.insert(40);
    //返回插入结果，set无法插入相同元素
    pair<set<int, less<int>>::iterator, bool> res = _set.insert(11);
    //res.first 为第一个参数迭代器
    //res.second 为第二个参数布尔
    if (res.second) {
        cout << "插入成功" << endl;
    } else {
        cout << "插入失败" << endl;
    }
    //遍历
    for (auto it = _set.begin(); it != _set.end() ; it ++) {
        cout << *it << endl;
    }
    return 0;
}

集合map，multimap

#include <iostream>
#include <map>

using namespace std;

int main(){
    //map会对key进行排序，key不能重复
    map<int, string> _map;
    //插入第一种
    _map.insert(pair<int, string>(1, "a"));
    //插入第二种
    _map.insert(make_pair(2, "b"));
    //插入第三种
    _map.insert(map<int, string>::value_type(3, "c"));
    //插入第四种，也用于修改
    _map[4] = "d";
    _map[1] = "aa";
    //遍历
    //源码提供的迭代器：iterator(默认，从头到尾) reverse_iterator(从尾到头)  const_iterator(只读)
    for (map<int, string>::iterator it = _map.begin(); it != _map.end(); it++) {
        cout << it->first << "," << it->second << endl;
    }
    //根据key查value
    auto it = _map.find(5);
    if (it != _map.end()) {
        cout << "value = " + it->second << endl;
    } else {
        cout << "no value" << endl;
    }

    //multimap会对key排序，key可以重复，可以根据key分组，value排序
    multimap<int, string> _multimap;
    _multimap.insert(make_pair(1, "a"));
    _multimap.insert(make_pair(1, "aa"));
    _multimap.insert(make_pair(1, "aaa"));
    _multimap.insert(make_pair(2, "bbb"));
    _multimap.insert(make_pair(2, "b"));
    _multimap.insert(make_pair(2, "bb"));
    _multimap.insert(make_pair(3, "cc"));
    _multimap.insert(make_pair(3, "c"));
    _multimap.insert(make_pair(3, "ccc"));
    //遍历
    for (auto it = _multimap.begin(); it != _multimap.end(); it++) {
        cout << it->first << "," << it->second << endl;
    }
    //根据key查value
    int key = 1;
    auto multiIt = _multimap.find(key);
    while (multiIt != _multimap.end()) {
        cout << key << "->value = " + multiIt->second << endl;
        //移动迭代器指针
        multiIt++;
        //key变了跳出循环
        if (multiIt->first != key) {
            break;
        }
        //严谨性代码判断
        if (multiIt == _multimap.end()) {
            break;
        }
    }
    return 0;
}