C++语言基础：STL----stack / queue / list / set / multiset / map / multimap

• 2、STL常用容器
  • 2.1、string
  • 2.2、vector
  • 2.3、deque
  • 2.4、stack
    • 2.4.1、stack基本概念
      • 1、概念
        • stack是一种先进后出（First In Last Out, FILO）的数据结构，它只有一个出口

          

        • 栈中只有顶端的元素才可以被外界使用，因为栈不允许有遍历行为
    • 2.4.2、stack常用接口
      • 1、构造函数
        • 1. stack<T> stk; // stack采用模板类实现，stack对象的默认构造形式
        • 2. stack(const stack & stk); // 拷贝构造函数
      • 2、赋值操作
        • 1. stack& operator=(const stack & stk); // 重载等号操作
      • 3、数据存取
        • 1. push(elem); // 栈顶添加元素
        • 2. pop(); // 栈顶移除元素
        • 3. top(); //返回栈顶元素
      • 4、大小操作
        • 1. empty(); // 判断堆栈是否为空
        • 2. size(); // 返回栈的大小
  • 2.5、queue
    • 2.5.1、queue基本概念
      • 1、基本概念
        • queue是一种先进先出（First In First Out, FIFO）的数据结构，它有两个出口

          

        • 队列元素允许从一端新增元素，从另一端移除元素
        • 队列中只有队头和对尾才可以被外界使用，因此队列不可以遍历
        • 入队push：队列中进数据，对尾进数据
        • 出队pop：队列中弹出数据，队头出数据
    • 2.5.2、queue常用接口
      • 1、构造函数
        • 1. queue<T> que; // queue采用模板类实现，queue对象的默认构造形式
        • 2. queue(const queue& que); // 拷贝构造函数
      • 2、赋值操作
        • 1. queue& operator=(const queue& que); // 重载等号操作
      • 3、数据存取
        • 1. push(elem); // 队尾添加元素
        • 2. pop(); // 队头移除元素
        • 3. back(); //返回队尾元素
        • 4. front(); //返回队头元素
      • 4、大小操作
        • 1. empty(); // 判断堆栈是否为空
        • 2. size(); // 返回栈的大小
  • 2.6、list
    • 2.6.1、list基本概念
      • 1、功能：将数据进行链式储存
      • 2、链表list：是一种物理存储单元上非连续的存储结构，数据元素的逻辑顺序是通过链表中的指针链接实现的。
      • 3、链表的组成
        • 链表由一系列结点组成
      • 4、结点的组成：一个是存储数据元素的数据域，另一个是存储下一个阶段地址的指针域
      • 5、STL中的链表是一个双向循环链表

        

        • 由于链表的存储方式并不是连续的内存空间，因此链表list中的迭代器只支持前移和后移，属于双向迭代器
      • 6、list的优点
        • 1. 采用动态存储分配，不会造成内存浪费和溢出
        • 2. 链表执行插入和删除操作十分方便，修改指针即可，不需要移动大量元素
      • 7、list的缺点
        • 链表 灵活，但是空间（指针域）和时间（遍历）额外耗费较大
      • 8、list有一个重要的性质，插入操作和删除操作都不会造成原有list迭代器的实失效，这在vector是不成立的
      • 9、总结
        • STL中list和vector是两个最常被使用的容器，各有优缺点；
    • 2.6.2、list构造函数
      • 1、功能描述：创建list容器
      • 2、函数原型
        • 1. list<T> lst; // 1. list采用模板类实现，对象的默认构造形式
        • 2. list(begin, end); //2. 构造函数将[begin, end) 区间中的元素拷贝给本身
        • 3. list(n, elem); // 3. 构造函数将n个elem拷贝给本身
        • 4. list(const list& lst); //4. 拷贝构造函数
    • 2.6.3、list赋值和交换操作
      • 1、功能描述：给list容器进行赋值，以及交换list容器
      • 2、函数原型
        • 1. list& operator=(const list& lst); // 1.重载等号操作符
        • 2. assign(beg, end); // 2.将[beg, end)区间的数据拷贝赋值给list本身
        • 3. assign(n, elem); // 3.将n个elem拷贝赋值给本身
        • 4. swap(lst); // 4. 将lst与本身的元素互换
    • 2.6.4、list容量和大小
      • 函数原型
        • 1. empty(); // 判断容器是否为空
        • 2. size(); // 返回容器中元素的个数
        • 3. resize(int num); // 重新指定容器的长度，如果容器变长，则以默认值0填充新位置；如果容器变短，则末尾超出容器长度的元素被删除
        • 4. resize(int num, elem); // 重新指定容器的长度，如果容器变长，则以elem值填充新位置；如果容器变短，则末尾超出容器长度的元素被删除
    • 2.6.5、list插入和删除
      • 函数原型
      • 两端插入、删除操作
        • 1. push_back(ele); // 尾部插入元素ele
        • 2. push_front(ele); // 头部插入元素ele
        • 3. pop_back(); // 删除最后一个元素
        • 4. pop_front(); // 删除第一个元素
      • 两端插入、删除操作
        • 5. insert(const_iterator pos, ele); //向指定位置pos插入元素ele，注意是插入，并非替换，返回新数据的位置
        • 6. insert(const_iterator pos, int count, ele); //向指定位置pos插入count个元素ele，无返回值
        • 7. insert(const_iterator pos, int begin, int end); //向指定位置pos插入区间[begin, end)的元素，无返回值
        • 8. erase(const_iterator pos); // 删除pos位置的元素，返回下一个元素的位置
        • 9. erase(const_iterator start, const_iterator end); // 删除迭代器从[start,end)之间的元素，返回下一个元素的位置
        • 10. clear(); // 删除容器中所有的元素
        • 11. remove(elem); 删除容器中所有与elem匹配的元素
    • 2.6.6、list数据的存取
      • 函数原型
        • 1. front(); // 返回容器第一个元素
        • 2. back(); // 返回最后一个元素
    • 2.6.7、list反转和排序
      • 函数原型
        • 1. reverse(); // 反转链表
        • 2. sort(); // 链表排序
  • 2.7、set / multiset
    • 2.7.1、set 基本概念
      • 1、简介：所有元素都会在插入时自动排序
      • 2、本质：set / multiset属于关联式容器，底层结构是用二叉树实现的
      • 3、set 与 multiset的区别
        • 1. set不允许容器中有重复元素
        • 2. multiset允许容器中有重复元素
    • 2.7.2、set 构造函数
      • 1、函数原型
        • 1. set<T> st; // 1.默认构造形式
        • 2. set(const set& st); //2. 拷贝构造函数
    • 2.7.3、set 赋值和交换操作
      • 1、函数原型
        • 1. set& operator=(const set& st); // 1.重载等号操作符
        • 2. swap(st); // 2. 交换两个集合容器
    • 2.7.4、set 判空和大小
      • 1、函数原型
        • 1. empty(); // 判断容器是否为空
        • 2. size(); // 返回容器中元素的个数
    • 2.7.5、set 插入和删除
      • 1、函数原型
        • 1. insert(ele); //插入元素ele，无返回值
        • 2. clear(); // 删除容器中所有的元素
        • 3. erase(const_iterator pos); // 删除pos位置的元素，返回下一个元素的位置
        • 4. erase(const_iterator start, const_iterator end); // 删除迭代器从[start,end)之间的元素，返回下一个元素的位置
        • 5. erase(elem); // 删除容器中所有为elem的元素
    • 2.7.7、set查找和统计
      • 函数原型
        • 1. find(key); // 查找key是否存在，返回该键的元素的迭代器；若不存在，则返回set.end();
        • 2. count(key); // 统计key的元素的个数
    • 2.7.7、set / multiset的区别
      • 1、区别
        • 1. set不允许容器中有重复元素，set插入数据会返回插入结果，表示是否插入成功。
        • 2. multiset允许容器中有重复元素。不会检测数据，因此可以插入重复数据
    • 2.7.8、pair对组创建
      • 1、功能描述：
        • 成对出现的数据，利用对组可以返回两个数据
      • 2、两种创建方式
        • 1. pair<type, type> p (value1, value2);
        • 2. pair<type, type> p = make_pair(value1, value2);
      • 3、示例

        • void test01() {
              pair<string, int>p("tom", 20);
              cout << p.first << p.second << endl; // tom20
              pair<string, int>p2 = make_pair("jerry", 23);
              cout << p2.first << p2.second << endl; // jerry23
          }
          

    • 2.7.9、set容器排序
      • 1、学习目标
        • set容器默认排序规则为从小到大，掌握如何改变规则
      • 2、技术点
        • 利用仿函数，可以改变排序规则
      • 3、示例
        • 示例一：逆序排列set

          • class MyCompare1
            {
            public:
                bool operator()(int v1, int v2) {
                    return v1 > v2;
                }
            };
            void test01() {
                set<int, MyCompare1> s1;
                s1.insert(40);
                s1.insert(50);
                s1.insert(30);
                s1.insert(20);
                s1.insert(10);
                for (set<int, MyCompare1>::iterator it = s1.begin(); it != s1.end(); it++) {
                    cout << *it << " ";
                }
                cout << endl;
            }
            

  • 2.8、map/multimap
    • 2.7.1、map基本概念
      • 1、简介
        • 1. map中所有元素都是pair
        • 2. pair中第一个元素为key（键值），起到索引作用，第二个元素为value（实值）
        • 3. 所有元素都根据元素的键值自动排序
      • 2、本质
        • 1. map/multimap都是关联式容器，底层结构是二叉树实现
      • 3、优点
        • 1. 可以根据key值快速找到value值
      • 4、map/multimap的区别
        • 1. map 不允许容器中有重复的key值元素
        • 2. multimap 允许容器中有重复的key值元素
    • 2.7.2、map构造函数
      • 1、函数原型
        • 1. map<T1, T2> mp; // 1.默认构造形式
        • 2. map(const map& mp); //2. 拷贝构造函数
    • 2.7.3、map赋值和交换操作
      • 1、函数原型
        • 1. map& operator=(const map& mp); // 1.重载等号操作符
        • 2. swap(mp); // 2. 交换两个集合容器
    • 2.7.4、map判空和大小
      • 1、函数原型
        • 1. empty(); // 判断容器是否为空
        • 2. size(); // 返回容器中元素的个数
    • 2.7.5、map插入和删除
      • 1、函数原型
        • 1. insert(ele); //插入元素ele，无返回值
        • 2. clear(); // 删除容器中所有的元素
        • 3. erase(const_iterator pos); // 删除pos位置的元素，返回下一个元素的位置
        • 4. erase(const_iterator start, const_iterator end); // 删除迭代器从[start,end)之间的元素，返回下一个元素的位置
        • 5. erase(key); // 删除容器中值为key的元素
    • 2.7.6、map查找和统计
      • 函数原型
        • 1. find(key); // 查找key是否存在，返回该键的元素的迭代器；若不存在，则返回map.end();
        • 2. count(key); // 统计key的元素的个数
    • 2.7.7、map容器排序
      • 1、学习目标
        • map容器默认排序规则为从小到大，掌握如何改变规则
      • 2、技术点
        • 利用仿函数，可以改变排序规则