C++ stl容器详解(y总算法基础课 stl 容器 笔记记录)

c++分配空间所用的时间长短与分配的次数有关，与分配大小无关。

auto 类型的数据可以遍历所有stl容器

所有stl容器公有函数，且时间复杂度为O(1)：
    size() : 返回容器中的元素个数
    empty() : 返回容器是否为空, 空返回true, 非空返回false
    clear() : 清空sql容器(在队列，优先队列和栈中没有clear()该函数)
    
vector 变长数组(优化思路 : 减少申请次数(倍增思想，每次存满后将数组len*2)) :
    front() : 返回vector第一个数
    back() : 返回vector最后一个数
    push_back() : 在vector最后插入一个数
    pop_back() : 删除vector的最后一个数
    
    vector有迭代器 :
    begin() : vector的第一个数
    end() : vector的最后一个数的后面一个数
    vector支持比较运算，按字典序比较
    vector支持随机寻址
    
pair<int, string> p;
    p.first : 第一个元素
    p.second ： 第二个元素
    支持比较运算 :
        以first为第一关键字，以second为第二关键字进行比较
        (也是按照字典序进行比较)
    进行构造初始化pair类型数据 :
        P = make_pair(10, 'yxc') 
        p = {20, "abc"}
    可以嵌套 :
        pair<int, pair<int, int>> p;

string 字符串 : 
    substr(x, y) : 返回子串
        x是字串的起始位置，y是字串的长度。
        当y超出母串长度时，会输出到母串结束位置
        y可省略，省略时返回从x开始整个字串
    c_str() : 返回string对应的字符数组的头指针
    clear() : 清空字符串
    length()/size() : 效果相同，都是返回字符串长度

queue 队列:
    push() : 往队尾插入一个元素
    front() : 返回队头元素
    back() : 返回队尾元素
    pop() : 弹出队头元素
    初始化构造queue队列：
        q = queue<int>();
    
priority_queue 优先队列(实现原理是堆，默认是大根堆) :
    push() : 往队列中插入元素
    top() : 返回堆顶
    pop() : 弹出堆顶
    变成小根堆的方式 :
        priority_queue<int, vector<int>, greater<int>> heap;
    
stack 栈 : 
    push() : 往栈顶添加元素
    top() : 返回栈顶元素
    pop() : 弹出栈顶元素
    
deque 双端队列(加强版vector，缺点:慢的令人发指，比一般速度慢好几倍) :
    front() : 返回第一个元素
    back() : 返回最后一个元素
    push_back() : 向队尾插入一个元素
    pop_back() : 弹出最后一个元素
    push_front() : 向队首插入一个元素
    pop_front() : 从队首弹出一个元素
    支持随机寻址
    支持begin()/end()的迭代器
    
set, map, multiset, multimap 基于平衡二叉树(红黑树)实现的, 动态的维护有序序列。
    缺点：增删改查的时间复杂度为O(log(n))
    优点：支持 lower_bound()/upper_bound()函数, 和排序有关的操作都是支持的, 包括迭代器的++ --;
    set/multiset (所有操作的时间复杂度是Olog(n)):
        set : 建立不重复集合容器
        multiset : 建立可重复集合的容器
        insert() : 插入一个数
        find() : 查找一个数，
            不存在的话返回end()迭代器
        count() : 返回某个数的个数
        erase() :
            (1) 输入一个数x，删除所有等于这个数的节点; (时间复杂度O(k + log(n)) k是x的个数)
            (2) 输入一个迭代器，删除这个迭代器
        lower_bound()/upper_bound() :
            lower_bound(x) : 返回>=x的最小的数的迭代器，不存在返回end()
            upper_bound(x) : 返回>x的最小的数的迭代器，不存在返回end()
    map/multimap
        map : 把两个东西作映射
        multimap :
        insert() : 插入一个数, 参数的是一个pair
        erase() : 参数是一个pair或者迭代器
            (1) 输入一个数x，删除所有等于这个数的节点; (时间复杂度O(k + log(n)) k是x的个数)
            (2) 输入一个迭代器，删除这个迭代器
        find() : 查找一个数，
            不存在的话返回end()迭代器
        可以如同数组一样使用map, [] 但时间复杂度是O(log(n))
        
unordered_set, unordered_map, unordered_multiset, unordered_multimap 基于哈希表实现的 :
    跟上面类似
    优势：增删改查的时间复杂度为O(1)
    缺点：不支持 lower_bound()/upper_bound()函数, 和排序有关的操作都是不支持的, 包括迭代器的++ --;

bitset 压位(压位后的数据占原数据空间的1/8, 常用于节省空间) :
    bitset<10000> s; 
        定义了一个长度为10000的bitset;
    支持各种位运算操作。
        ~s 取反
        & 与
        | 或
        ^ 异或
    支持移位操作 
        << 左移
        >> 右移
    支持判断操作
        == 相等
        != 不相等
    支持[]操作符，可以单独取出某一位 0或1
    count() : 返回有多少个1
    any() : 判断是否至少有一个1
    none() : 判断是否全为0
    set() : 把所有位 置成1
    set(k, v) : 将第k位变成v
    reset() : 把所有位变成0
    flip() : 等价与取反
    flip(k) : 把第k位取反。

/* 算法常用基础必备头文件 */
#include <iostream>
#include <algorithm>
#include <cstdio>

/* string 字符串 */
#include <cstring>

/* vector 变长数组 */
#include <vector>

/* 1:queue 队列 2:priority_queue 优先队列(堆，默认大根堆) */
#include <queue>

/* stack 栈 */
#include <stack>

/* deque 双端队列(加强版vector) */
#include <deque>

/* set, multiset */
#include <set>

/* map, multimap */
#include <map>

/* unordered_set, unordered_multiset */
#include <un_ordered_set>

/* unordered_map, unordered_multimap */
#include <unordered_map>

using namespace std;

int main()
{
    
    // /* vector 变长数组 */
    // // 定义一个基础的vector
    // vector<int> a;
    // // 定义一个长度为10的vector
    // vector<int> b(10);
    // // 定义一个长度为10的vector, 并全部初始化为3；
    // vector<int> c(10, -3);
    // // 定义了10个vector
    // vector<int> h[10];
    // for(int i = 0; i < 10; i ++) a.push_back(i);
    // // 第一种遍历方式
    // for(int i = 0; i < a.size(); i ++) cout << a[i] << ' ';
    // cout << endl;
    // // 第二种遍历方式(vector迭代器) 迭代器结果相当于指针，前缀加*可以去除引用
    // // a.begin() == a[0], a.end() == a[a.size()]
    // // vector<int>::iterator 可以写成 auto 
    // // auto可以自动推断数据类型
    // for(vector<int>::iterator i = a.begin(); i != a.end(); i ++) cout << *i << ' ';
    // cout << endl;
    // // 第三种遍历方式(c ++ 中的范围遍历)
    // for(auto x : a) cout << x << ' ';
    // cout << endl;
    // // vector支持比较运算，按字典序比较
    // vector<int> d(4, 3), e(3, 4);
    // if(d < e) puts("d < e");
    
    
    
    
    // /* string 字符串 */
    // string a = "yxc";
    // a += "def";
    // a += 'c';
    // cout << a << endl;
    
    // // a.substr(x, y) ->> 返回字串;
    // // x是字串的起始位置，y是字串的长度。
    // // 当y超出母串长度时，会输出到母串结束位置
    // // y可省略，省略时返回从x开始整个字串
    // cout << a.substr(1, 2) << endl;
    
    // // c_str() : 返回string对应的字符数组的头指针
    // printf("%s\n", a.c_str());
    
    
    
    
    // /* queue 队列 */
    // queue<int> q;
    // // 构造初始化队列
    // q = queue<int>();
    
    // /* priority_queue 优先队列(默认是大根堆) */
    // priority_queue<int> heap;
    
    // // 如何用用stl容器定义一个小根堆
    // // 方法一(priority_queue 优先队列 快捷方便) : 
    // // -x从大到小排序，既是x从小到大排序
    // heap.push(-x);
    
    // //方法二(用到队列) :
    // priority_queue<int, vector<int>, greater<int>> heap;
    
    
    
    
    // /* set, multiset */
    // // set<int> s; 无重复元素的集合
    // // multiset<int> MS; 有重复元素的集合
    // set<int> s;
    // multiset<int> MS;
    
    
    
    // /* map, multimap */
    // map<string, int> a;
    // a["yxc"] = 1;
    // cout << a["yxc"] << endl;
    
    // // 所有stl容器公有函数,且时间复杂度为O(1)
    // a.size(); // 返回a中的元素个数
    // a.empty(); // 返回a是否为空, 空返回true, 非空返回false
    // a.clear(); // 清空sql容器(在队列，优先队列和栈中没有clear()该函数)
    
    return 0;
}


​

​