代码训练营 day11|LeetCode 150，LeetCode 239，LeetCode 347

前言

这里记录一下陈菜菜的刷题记录，主要应对25秋招、春招
个人背景
211CS本+CUHK计算机相关硕，一年车企软件开发经验
代码能力：有待提高
常用语言：C++

系列文章目录

第一天 数组 part01

第二天 数组 part02

第三天 链表 part01

第四天 链表 part02

第五天 休息

第六天 哈希表 part01

第七天：第三章 哈希表part02

第八天 ：第四章 字符串part01

第九天 ：第四章 字符串part02

第十天 ：第五章 栈与队列part01

第十一天 ：第五章 栈与队列part02

---

`

---

---

一、今日任务

● 150. 逆波兰表达式求值
● 239. 滑动窗口最大值
● 347.前 K 个高频元素
● 总结

二、详细布置

150. 逆波兰表达式求值

题目链接：[力扣150]https://leetcode.cn/problems/evaluate-reverse-polish-notation/)
文章讲解：代码随想录

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

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

注意：

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

提示：

1 <= tokens.length <= 104
tokens[i] 是一个算符（“+”、“-”、“*” 或 “/”），或是在范围 [-200, 200] 内的一个整数

样例1：

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

样例2：

输入：tokens = ["4","13","5","/","+"]
输出：6
解释：该算式转化为常见的中缀算术表达式为：(4 + (13 / 5)) = 6

样例3：

输入：tokens = ["10","6","9","3","+","-11","*","/","*","17","+","5","+"]
输出：22
解释：该算式转化为常见的中缀算术表达式为：
  ((10 * (6 / ((9 + 3) * -11))) + 17) + 5
= ((10 * (6 / (12 * -11))) + 17) + 5
= ((10 * (6 / -132)) + 17) + 5
= ((10 * 0) + 17) + 5
= (0 + 17) + 5
= 17 + 5
= 22

思路

这题就是后缀表达式计算，梦回数据结构了。。。这应该是第一个一次过的中等题。思路简单，遇到数就压栈，遇到字符就出栈两个元素，把运算结果压栈，因为是后缀表达式，所以先出栈的是被操作数，后出栈的是操作数。唯一的一点是会遇到长整数或者负数，就要先把字符串转换成数字。再次感叹STL真好用！！

实战

class Solution {
public:
    int evalRPN(vector<string>& tokens) {
        int i;
        int len=tokens.size();
        stack<int> mystack;
        for(i=0;i<len;i++){
            if(tokens[i]!="+"&&tokens[i]!="-"&&tokens[i]!="*"&&tokens[i]!="/"){
                mystack.push(stoi(tokens[i]));
            }
            else{
                //if(mystack.size()<2)
                //    return
                int second=mystack.top();
                mystack.pop();
                int first=mystack.top();
                mystack.pop();
                if(tokens[i]=="+")
                    mystack.push(first+second);
                if(tokens[i]=="-")
                    mystack.push(first-second);
                if(tokens[i]=="*")
                    mystack.push(first*second);
                if(tokens[i]=="/")
                    mystack.push(first/second);
            }
        }
        return mystack.top();
    }
};

225. 用队列实现栈

题目链接：力扣225题链接
文章讲解：图文讲解

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

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

提示：

1 <= nums.length <= 105
-104 <= nums[i] <= 104
1 <= k <= nums.length

样例1：

输入：nums = [1,3,-1,-3,5,3,6,7], k = 3
输出：[3,3,5,5,6,7]
解释：
滑动窗口的位置                最大值
---------------               -----
[1  3  -1] -3  5  3  6  7       3
 1 [3  -1  -3] 5  3  6  7       3
 1  3 [-1  -3  5] 3  6  7       5
 1  3  -1 [-3  5  3] 6  7       5
 1  3  -1  -3 [5  3  6] 7       6
 1  3  -1  -3  5 [3  6  7]      7 

样例2：

输入：nums = [1], k = 1
输出：[1] 

思路

又达成成就了：十分钟写出困难题！！！感动。主要是借助滑动窗口的思想，每次只在K个数之间找最大值。找最值可以直接借助栈，最大/栈空就压栈，每次只跟栈顶元素比较。最后每遍历一次窗口把值赋给result数组，再把栈清空。

实战

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        int i,j;
        stack<int> mystack;
        vector<int> result;
        if(nums.size()<=k){
            sort(nums.begin(),nums.end());
            result.push_back(nums[nums.size()-1]);
        }
        else{
            for(i=0;i<=nums.size()-k;i++){
                stack<int> mystack;
                for(j=i;j<=i+k-1;j++){
                    if(mystack.empty()||nums[j]>mystack.top())
                        mystack.push(nums[j]);
                }
                result.push_back(mystack.top());
            }
        }
        return result;
    }
};

踩坑

当k>=nums.size()时要先判断，不然会陷入循环。直接sort就好，把最大值返回。

347.前 K 个高频元素

题目链接：LeetCode347
文章讲解：图文讲解

题目描述

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

提示：

1 <= nums.length <= 105
k 的取值范围是 [1, 数组中不相同的元素的个数]
题目数据保证答案唯一，换句话说，数组中前 k 个高频元素的集合是唯一的

样例1：

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

样例2：

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

思路

这题我知道用堆做是最简单的，但是奈何不会用代码实现。
码一下，这题可以当模板记住了。

实战

class Solution {
public:
    // 小顶堆
    class mycomparison {
    public:
        bool operator()(const pair<int, int>& lhs, const pair<int, int>& rhs) {
            return lhs.second > rhs.second;
        }
    };
    vector<int> topKFrequent(vector<int>& nums, int k) {
        // 要统计元素出现频率
        unordered_map<int, int> map; // map<nums[i],对应出现的次数>
        for (int i = 0; i < nums.size(); i++) {
            map[nums[i]]++;
        }

        // 对频率排序
        // 定义一个小顶堆，大小为k
        priority_queue<pair<int, int>, vector<pair<int, int>>, mycomparison> pri_que;

        // 用固定大小为k的小顶堆，扫面所有频率的数值
        for (unordered_map<int, int>::iterator it = map.begin(); it != map.end(); it++) {
            pri_que.push(*it);
            if (pri_que.size() > k) { // 如果堆的大小大于了K，则队列弹出，保证堆的大小一直为k
                pri_que.pop();
            }
        }

        // 找出前K个高频元素，因为小顶堆先弹出的是最小的，所以倒序来输出到数组
        vector<int> result(k);
        for (int i = k - 1; i >= 0; i--) {
            result[i] = pri_que.top().first;
            pri_que.pop();
        }
        return result;

    }
};

总结

今天主要学习了栈和队列的一系列操作，今天解锁了两个成就！太开心了，做出来困难题的时候！而且今天提前做完了，相当于双休了！开心，明天奖励自己吃好的！
加油，坚持打卡的第十天。