STL常用容器之deque、stack、queue、list

deque容器

• 功能
  • 双端数组，可以对头端进行插入删除操作
• deque与vector区别
  • vector对于头部的插入删除效率太低
  • deque相对而言，头部插入删除速度比vector更快
  • vector访问元素时的速度会比deque快
• deque内部工作原理
  • deque内部有个中控器，维护每段缓冲区中的内容，缓冲区中存放真实数据
  • 中控器维护的是每个缓冲区的地址，使得使用deque时像一片连续的内存空间
• 构造函数
  • 原型
    • deque < T >
    • deque(beg, end)
    • deque(n, elem)
    • deque(const deque &deq)
• 赋值操作
  • deque& operator=(const deque &deq)
  • assign(beg, end)
  • assign(n, elem)
• 大小操作
  • deque.empty()
  • deque.size()
  • deque.resize(len)
  • deque.resize(len, elem)
• 插入和删除
  • 两端插入操作
    • push_back(elem)
    • push_front(elem)
    • pop_back()
    • pop_front()
  • 指定位置操作—提供迭代器
    • insert(pos, elem)
    • insert(pos, n, elem)
    • insert(pos, beg, end)
    • clear()
    • erase(beg, end)
    • erase(pos)
• deque数据存取
  • at(int idx)
  • operator[]
  • front()
  • back()
• deque排序
  • 利用算法对deque容器进行排序
  • 算法
    • sort(iterator beg, iterator end)—对beg和end区间内的元素进行排序—升序
  • 支持随机访问的迭代器都可以使用sort算法进行排序

stack容器

• 概念
  • 先进后出的一种容器，只有一个出口
  • 栈顶才能进出—top()—push()—pop()
  • 开口处是栈顶
  • 栈无遍历行为
  • 栈可以判断容器为空
  • 栈可返回元素个数
• stack常用接口
  • 构造函数
    • stack< T >stk
    • stack(const stack &stk)—拷贝构造函数
  • 赋值操作
    • stack& operator=(const stack &stack)
  • 数据存取
    • push(elem)
    • pop()
    • top()
  • 大小操作
    • empty()
    • size()—返回大小

queue容器

• 队列概念
  • 先进先出的数据结构
  • 有两个口，push(),pop()
• 常用接口
  • 构造函数
    • queue< T > que
    • queue(const queue &que)
  • 赋值操作
    • queue& operator=(const queue &que)
  • 数据存取
    • push(elem)—队尾添加元素
    • pop()
    • back()
    • front()
  • 大小操作
    • empty()
    • size()

list容器

• 概念
  • 将数据进行链式存储
  • 链表
    • 是一种物理存储单元上非连续的存储结构，数据元素的逻辑顺序就是通过链表中指针链接实现的
  • 链表组成
    • 链表有一系列结点组成
  • 结点的组成
    • 一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域
  • STL中的链表
    • 双向循环链表
  • 优点
    • 可以在任意位置快速插入删除
    • 采用动态分配，不会造成内存浪费和溢出
  • 缺点
    • 遍历速度不快
  • 与vector的区别
    • list插入操作和删除操作都不会造成原有list迭代器失效，这在vector中是不成立的
• 构造函数
  • 原型
    • list < T > lst
    • list(beg, end)
    • list(n, elem)
    • list(const list &lst)
• 赋值和交换
  • 功能
    • 给list容器进行赋值，以及交换list容器
  • 原型
    • assign(beg, end)
    • assign(n, elem)
    • list& operator=(const list &lst)
    • swap(lst)
• 大小操作
  • 功能
    • 对list容器的大小进行操作
  • 原型
    • size()
    • empty()
    • resize(len)
    • resize(len, elem)
• 插入和删除
  • push_back(elem)
  • pop_back()
  • push_front(elem)
  • pop_front()
  • insert(pos, elem)—在pos位置插入elem元素的拷贝，返回新数据的位置
  • insert(pos, n, elem)—无返回值
  • insert(pos, beg, end)—无返回值
  • clear()
  • erase(beg, end)—删除左闭右开的数据，返回下一个数据的位置
  • erase(pos)—删除pos位置的数据，返回下一个数据的位置
  • remove(elem)—删除容器中所有与elem值匹配的元素
• 数据存取
  • 原型
    • front()—返回第一个元素
    • back()—返回最后一个元素
  • 注意
    • list[]不可以访问list中的元素
    • 原因list本质是链表，不是用连续线性空间存储数据，迭代器也是不支持随机访问的
• 反转和排序
  • 原型
    • reverse()—反转链表
    • sort()—链表排序
      • 但是不是标准算法，因为不支持随机访问迭代器的容器内部会提供成员函数
      • list.sort()—默认从小到大排列
      • 如何实现降序排列

        bool myCompare(int v1, int v2){
            return v1 > v2;
        }
        list.sort(myCompare);
      

• 排序案例—自定义数据类型
  • 需求—按照年龄进行升序，如果年龄相同按照身高进行降序—排序要指定规则

    #include<iostream>
    #include<string>
    #include<list>
    using namespace std;
  
    class Person{
        public:
            string m_name;
            int m_age;
            int m_heigth;
        Person(string name, int age, int height){
            this->m_name = name;
            this->m_age = age;
            this->m_heigth = height;
        }
    };
    // 排序规则
    bool myCompare(Person &p1, Person &p2){
        if(p1.m_age != p2.m_age){
            return p1.m_age < p2.m_age;
        }else{
            return p1.m_heigth > p2.m_heigth;
        }
    }
    void myPrint(list<Person> &list){
        for(auto it = list.begin(); it != list.end(); it++){
            cout << "name " << (*it).m_name << "age " << (*it).m_age << "height" << (*it).m_heigth << endl;
        }
    }
    void test(void){
        // 创建list容器
        list<Person> list;
        // 准备数据
        Person p1("zhangsan", 18, 180);
        Person p2("wangwu", 18, 160);
        Person p3("zhaosi", 25, 170);
        // 放入容器
        list.push_back(p1);
        list.push_back(p2);
        list.push_back(p3);
        // 未排序前
        myPrint(list);
        // 排序后
        list.sort(myCompare);
        myPrint(list);
    }
    int main(){
        test();
        return 0;
    }