栈和队列篇--代码随想录算法训练营第十一天|150.逆波兰表达式求值，239.滑动窗口最大值，347.前 K 个高频元素

优先级队列常用操作

头文件: # include < queue > 在队列的基础上将内部进行排序, 默认降序, 只能访问头部

1、构造函数

priority_queue <int> pq, pq1;//定义 int 类型的优先队列
priority_queue <char> pqch;//定义 char 类型的优先队列
priority_queue <string> pqstr;//定义 string 类型的优先队列
priority_queue <int> pq2(pq);//定义新容器, 拷贝 pq 所有的元素
priority_queue <int, vector<int> > pq3;//使用 vector 容器实现优先队列
priority_queue <int, vector <int>, greater <int> > pq2;//升序排列容器内元素.

2、成员函数

pq.top();//返回队列头部元素
pq.push(5);//在队列尾部插入新元素 5
pq.emplace(5);//在队列尾部创建新元素 5
pq.pop();//删除队列头部元素
pq.size();//返回容器目前的元素个数
pq.empty();//容器为空返回true, 否则返回 false
pq.swap(pq1);//交换两个容器的内容

 

150.逆波兰表达式求值

题目链接：150.逆波兰表达式求值

讲解视频：栈的最后表演！ | LeetCode：150. 逆波兰表达式求值

题目描述：

给你一个字符串数组 tokens ，表示一个根据 逆波兰表示法 表示的算术表达式。

请你计算该表达式。返回一个表示表达式值的整数。

注意：

• 有效的算符为 '+'、'-'、'*' 和 '/' 。
• 每个操作数（运算对象）都可以是一个整数或者另一个表达式。
• 两个整数之间的除法总是 向零截断 。
• 表达式中不含除零运算。
• 输入是一个根据逆波兰表示法表示的算术表达式。
• 答案及所有中间计算结果可以用 32 位 整数表示。

示例 1：

输入：tokens = ["2","1","+","3","*"]
输出：9
解释：该算式转化为常见的中缀算术表达式为：((2 + 1) * 3) = 9

解题思路：

代码：

class Solution {
public:
    int toInteger(string s)
    {
        int sum = 0;
        int flag = 1;
        for(auto x : s)
        {
            if(x == '-') flag = -1;
            else sum = sum * 10 + x - '0';
        }
            
        return sum * flag;
    }

    int evalRPN(vector<string>& tokens) {
        stack<int> st;
        for(auto x : tokens)
        {
            if(x == "+" || x == "-" || x == "*" || x == "/") 
            {
                int b = st.top();
                st.pop();
                int a = st.top();
                st.pop();
                if(x == "+") st.push(a+b);
                else if(x == "-") st.push(a - b);
                else if(x == "*") st.push(a * b);
                else st.push(a/b);
            }
            else 
            {
                int tmp = toInteger(x);
                st.push(tmp);
            }
        }
        return st.top();
    }
};

 

239.滑动窗口最大值

题目链接：239.滑动窗口最大值

讲解视频：单调队列正式登场！

题目描述：

给你一个整数数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。

返回 滑动窗口中的最大值 。

解题思路：

单调队列思想

 假设有一个这样的队列，其具有如下三个功能：

1. 出队列：当形参与队列头元素相等时执行该功能。
2. 入队列：最终目的是形成一个单调减队列，每次执行时将入队元素与队列中已有元素进行比较，比入队元素小的元素出队列。
3. 获取队列中max值。

滑动窗口实现方式：
先将x个元素入队（x为窗口大小），之后在数组中每向后读取一个元素，就从队列中弹出一个元素，将新元素插入其中

代码：

class Solution {
public:
    class Myqueue{
    public:
        Myqueue(){}
        void pop(int val)
        {
            if(!q.empty() && q.front() == val) q.pop_front();
        }

        void push(int val)
        {
            while(!q.empty() && q.back() < val) q.pop_back();
            q.push_back(val);
        }

        int maxVal()
        {
            return q.front();
        }
    private:
        deque<int> q;
    };

public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        vector<int> result;
        Myqueue q;
        for(int i = 0; i < k; i++)
            q.push(nums[i]);
        result.push_back(q.maxVal());
        for(int i = k; i < nums.size(); i++)
        {
            q.pop(nums[i-k]);
            q.push(nums[i]);
            result.push_back(q.maxVal());
        }
        return result;
        
    }
};

 
347.前 K 个高频元素

题目链接：347.前 K 个高频元素

讲解视频：优先级队列正式登场！大顶堆、小顶堆该怎么用？

题目描述：

给你一个整数数组 nums 和一个整数 k ，请你返回其中出现频率前 k 高的元素。你可以按 任意顺序 返回答案。

示例 1:

输入: nums = [1,1,1,2,2,3], k = 2
输出: [1,2]

解题思路：

即需要数组中的数值，有需要数字出现的个数--->使用哈希表存储

每次需要得到最值--->堆

需要前k个频率最大值--->由于要统计最大前k个元素，只有小顶堆每次将最小的元素弹出，最后小顶堆里积累的才是前k个最大元素，因此需要只能容纳k个数的小根堆

代码：

class Solution {
public:
    class mycmp{
    public:
        bool operator()(pair<int,int> lx, pair<int,int> rx)
        {
            return lx.second > rx.second;
        }  
    };

    vector<int> topKFrequent(vector<int>& nums, int k) {
        unordered_map<int,int> hash;
        for(int i = 0; i < nums.size(); i++)
            hash[nums[i]]++;
        
        priority_queue<pair<int,int>,vector<pair<int,int>>,mycmp> pri_q;
        for(auto it = hash.begin(); it != hash.end(); it++)
        {
            pri_q.push(*it);
            if(pri_q.size() > k) pri_q.pop();
        }

        vector<int> result;
        for(int i = k-1; i >= 0; i--)
        {
            result.push_back(pri_q.top().first);
            pri_q.pop();
        }
        return result;
    }
};

栈和队列总结