详解C++适配器——stack栈、queue队列、priority_queue优先级队列

适配器前言：

适配器是一种设计模式(设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结)，该种模式是将一个类的接口转换成客户希望的另外一个接口。

目录

• stack栈
  • stack栈的使用
  • 最小栈的实现
• queue队列
  • queue队列的使用
  • 二叉树的层序遍历
• priority_queue优先级队列
  • priority_queue的使用
  • 仿函数的介绍
  • topK问题

stack栈

stack栈的使用

最小栈的实现

最小栈可以用两个栈来实现
一个栈同来正常数据进出，另一个栈用来获取前一个栈的最小值
栈的最小值即为min_stack的栈顶值
最小栈的入栈：
1.若入栈比的值比min_stack栈顶的值小，则入min_stack栈。否则不入

最小栈的出栈：
1.若出栈时，stack栈顶和min_stack栈顶的值相等，则出min_stack栈顶的值。否则不出

参考代码

class MinStack 
{
  stack<int> st;
  stack<int> min_stack;
public:
  /** initialize your data structure here. */
  MinStack() {
  }
  void push(int x) 
  {
    st.push(x);   
    if(min_stack.empty() || x <= min_stack.top())
      min_stack.push(x);
  }
   
  void pop() 
  {
    if(!st.empty())
    {
      int val = st.top();
      st.pop();   
      if(val == min_stack.top())
        min_stack.pop();
    }
  }
   
  int top() 
  {
    //assert(!st.empty());
    return st.top();   
  }
   
  int getMin() 
  {
      return min_stack.top();   
  }
};

queue队列

queue队列的使用

二叉树的层序遍历

1. 二叉树的层序遍历与队列紧密相关，得益于队列的先入先出的特殊结构
   
2. 一层一层遍历
3. 每个结点出队列的同时将自己的左孩子和右孩子入队列

参考代码如下：

vector<vector<int>> levelOrder(TreeNode* root) {
    vector<vector<int>> vv;
    if (root == nullptr)
        return vv;
    queue<TreeNode*> q;
    TreeNode* cur = root;
    q.push(cur);
    while (!q.empty())
    {
        int levelSize = q.size();
        vector<int> v;
        for (int i = 0; i < levelSize; ++i)
        {
            v.push_back(q.front()->val);
            q.pop();

            if (cur->left)
                q.push(cur->left);
            if (cur->right)
                q.push(cur->right);
            if (!q.empty())
                cur = q.front();
        }
        vv.push_back(v);
        
    }
    return vv;
}

priority_queue优先级队列

priority_queue的使用

如有不懂如何构建大堆小堆的，可以看我往期博客

priority_queue默认为大堆
问：怎么让他改为小堆呢？

仿函数的介绍

仿函数就是一个类对（）进行重载

如何让priority_queue构造成小堆？

topK问题

有两种解决方案

方法一(大堆)：
1. 将数组中所有元素进堆
2.pop掉前k个元素，就可以得到第k大的了

方法二(小堆)：
1.建立k大小的小堆
2.遍历数组中的元素若比小堆堆顶大则进堆
3.遍历完后堆顶就是第k大的了

方法二可以处理极大量的数据，而方法一局限于大量数据

1. 用大堆解决(不推荐)
2. 用小堆解决(推荐)

参考代码：

//大堆
int findKthLargest(vector<int>& nums, int k) {
        priority_queue<int> pq;
        for (auto& e : nums)
        {
            pq.push(e);
        }
        while (--k)
        {
            pq.pop();
        }
        return pq.top();
    }
//小堆
int findKthLargest(vector<int>& nums, int k) {
        priority_queue<int, vector<int>, greater<int>> pq;
        int i = 0;
        while (k--)
        {
            pq.push(nums[i++]);
        }

        for (; i < nums.size(); ++i)
        {
            if (nums[i] > pq.top())
            {
                pq.pop();
                pq.push(nums[i]);
            }
        }
        return pq.top();

    }