（补）算法训练Day13 | LeetCode150. 逆波兰表达式求值（栈应用）；LeetCode239. 滑动窗口最大值（单调队列）；LeetCode347. 前K个高频元素（小顶堆，优先级队列）

目录

LeetCode150. 逆波兰表达式求值

1. 思路

2. 代码实现

3. 复杂度分析

4. 思考

LeetCode239. 滑动窗口最大值

1. 思路

2. 代码实现

3. 复杂度分析

4. 思考

 LeetCode347. 前K个高频元素 

1. 思路

2. 代码实现

3. 复杂度分析

4. 思考

---

LeetCode150. 逆波兰表达式求值

链接：150. 逆波兰表达式求值 - 力扣（LeetCode）

1. 思路

来看一下本题，其实逆波兰表达式相当于是二叉树中的后序遍历。 大家可以把运算符作为中间节点，按照后序遍历的规则画出一个二叉树。但我们没有必要从二叉树的角度去解决这个问题，只要知道逆波兰表达式是用后续遍历的方式把二叉树序列化了，就可以了，举个栗子。

 在进一步看，本题中每一个子表达式要得出一个结果，然后拿这个结果再进行运算，那么这岂不就是一个相邻字符串消除的过程，和1047.删除字符串中的所有相邻重复项 (opens new window)中的对对碰游戏是不是就非常像了。

 这和1047. 删除字符串中的所有相邻重复项 (opens new window)是差不多的，只不过本题不要相邻元素做消除了，而是做运算！

2. 代码实现

# time:O(N);space:O(N)
class Solution:
    def evalRPN(self, tokens: List[str]) -> int:
        stack = []
        record = ["+","-","*","/"]
        for item in tokens:
            if item in record:
                num1 = int(stack.pop())
                num2 = int(stack.pop())
                if item == "+": stack.append(str(num2+num1))
                elif item == "-": stack.append(str(num2-num1))
                elif item == "*": stack.append(str(num2*num1))
                # 这里比较特殊，因为在C++里面 6/-132 = 0
                # 在Python里面6//-132= -1,所以int（num2/num1）是为了6/-132=0
                # 而且只有在Python3中才有用
                else: stack.append(str(int(num2/num1)))
            else: stack.append(item)
        return int(stack.pop())

3. 复杂度分析

时间复杂度：O(N)

需要从头到尾遍历一遍逆波兰表达式然后做相应的处理，时间复杂度为O(N）

空间复杂度：O(N)

需要另外一个栈，来保存遍历的逆波兰表达式的元素，空间复杂度O(N）

4. 思考

1. 代码中，有一些细节，在C++里面，6/-132 =0; 在Python里面6//-132 =-1；所以 int(number1 / number2))是为了 6/-132 =0，而且只有在Python3中才有用；

2. 我们习惯看到的表达式都是中缀表达式，因为符合我们的习惯，但是中缀表达式对于计算机来说就不是很友好了。

   例如：4 + 13 / 5，这就是中缀表达式，计算机从左到右去扫描的话，扫到13，还要判断13后面是什么运算法，还要比较一下优先级，然后13还和后面的5做运算，做完运算之后，还要向前回退到 4 的位置，继续做加法，你说麻不麻烦！

   那么将中缀表达式，转化为后缀表达式之后：["4", "13", "5", "/", "+"] ，就不一样了，计算机可以利用栈里顺序处理，不需要考虑优先级了。也不用回退了， **所以后缀表达式对计算机来说是非常友好的。**可以说本题不仅仅是一道好题，也展现出计算机的思考方式。在1970年代和1980年代，惠普在其所有台式和手持式计算器中都使用了RPN（后缀表达式），直到2020年代仍在某些模型中使用了RPN；

3. 在上一篇文章中**1047.删除字符串中的所有相邻重复项 (opens new window)提到了 递归就是用栈来实现的。所以栈与递归之间在某种程度上是可以转换的！** 这一点我们在后续讲解二叉树的时候，会更详细的讲解到。

Reference： 代码随想录 (programmercarl.com)

本题学习时间：70分钟。

---

LeetCode239. 滑动窗口最大值

链接：239. 滑动窗口最大值 - 力扣（LeetCode）

1. 思路

• 首先想到的是用暴力解法，遍历一遍的过程中每次从窗口中在找到最大的数值，但是这样很明显是O(n × k)的算法。
• 有的同学可能会想用一个大顶堆（优先级队列）来存放这个窗口里的k个数字，这样就可以知道最大的最大值是多少了， 但是问题是这个窗口是移动的，而大顶堆每次只能弹出最大值，我们无法移除其他数值，这样就造成大顶堆维护的不是滑动窗口里面的数值了。所以不能用大顶堆。

如何创造一个特殊的队列给此题使用呢？

此时我们需要一个队列，这个队列呢，放进去窗口里的元素，然后随着窗口的移动，队列也一进一出，每次移动之后，队列告诉我们里面的最大值是什么。

这个队列应该长这个样子：

class MyQueue {
public:
    void pop(int value) {
    }
    void push(int value) {
    }
    int front() {
        return que.front();
    }
};

每次窗口移动的时候，调用que.pop(滑动窗口中移除元素的数值)，que.push(滑动窗口添加元素的数值)，然后que.getMax()就返回我们要的最大值。

这么个队列香不香，要是有现成的这种数据结构是不是更香了！可惜了，没有！ 我们需要自己实现这么个队列。

如何实现呢？

再分析一下，队列里的元素一定是要排序的，而且要最大值放在出队口，要不然怎么知道最大值呢。但如果把窗口里的元素都放进队列里，窗口移动的时候，队列需要弹出元素。那么问题来了，已经排序之后的队列 怎么能把窗口要移除的元素（这个元素可不一定是最大值）弹出呢？而且这样和优先级队列没有本质区别呀。

大家此时应该陷入深思.....

其实队列没有必要维护窗口里的所有元素，只需要维护有可能成为窗口里最大值的元素就可以了，同时保证队里里的元素数值是由大到小的。

那么这个维护元素单调递减的队列就叫做单调队列，即单调递减或单调递增的队列。C++中没有直接支持单调队列，需要我们自己来一个单调队列。不要以为实现的单调队列就是 对窗口里面的数进行排序，如果排序的话，那和优先级队列又有什么区别了呢。

具体实施方法

对于窗口里的元素{2, 3, 5, 1 ,4}，单调队列里只维护{5, 4} 就够了，保持单调队列里单调递减，此时队列出口元素就是窗口里最大元素。

此时大家应该怀疑单调队列里维护着{5, 4} 怎么配合窗口经行滑动呢？

设计单调队列的时候，pop，和push操作要保持如下规则：

1. pop(value)：如果窗口移除的元素value等于单调队列的出口元素，那么队列弹出元素，否则不用任何操作
2. push(value)：如果push的元素value大于入口元素的数值，那么就将队列入口的元素弹出，直到push元素的数值小于等于队列入口元素的数值为止

保持如上规则，每次窗口移动的时候，只要问que.front()就可以返回当前窗口的最大值。

Example: [ 1,3,-1,0,5,3,4,7] ；k=3

1. 先把前K个元素放进去：

   push1：queue = [1]

   push3: queue = [ 3] (因为1小于3，所以pop掉1，然后再把3给push）

   push -1： queue = [ 3, -1] (因为-1 小于3，直接加在后面就好了）

   这时候result.push_back( queue.getfront) 。 result = [3]

2. 滑动窗口挪动，pop（1) ；push（0）

   1≠front nothing；小于0 的-1 被pop

   queue = [ 3,0 ] ; result = [3,3]

3. 滑动窗口挪动，pop（3）；push（5）

   3 = front ，3被从queue中移走；5大于queue中的0，0被pop

   queue = [5] ; result = [3,3,5]

4. 滑动窗口挪动，pop（-1）；push（3）

   -1 ≠ front nothing；3 直接加在5 后面

   queue = [5,3]; result = [3,3,5,5]

5. 滑动窗口挪动，pop（0）；push（4）

   0 ≠ front nothing；小于4的3，被pop掉，4 加在后面

   queue = [5,4] ; result = [3,3,5,5,5]

6. 滑动窗口挪动，pop（5）；push（7）

   5 = front；5被pop掉，4<7,也被pop掉；7加进去

   queue = [7]; result = [3,3,5,5,5,7] ；返回result作为结果。

用什么数据结构来实现这个单调队列呢？

• 使用deque最为合适，在文章**栈与队列：来看看栈和队列不为人知的一面 (opens new window)**中，我们就提到了常用的queue在没有指定容器的情况下，deque就是默认底层容器。
• 也可以用Python的list实现。

2. 代码实现

1. 用deque实现单调队列

# time:O(N);space:O(k)
class Solution(object):
    def maxSlidingWindow(self, nums, k):
        """
        :type nums: List[int]
        :type k: int
        :rtype: List[int]
        """
        que = MyQueue()
        res = []
        # 先把nums中的前K个元素放进单调队列中
        for i in range(k):
            que.push(nums[i])
        # 第一个窗口的最大值放进去
        res.append(que.getMax())
        # 开始遍历后面的窗口
        for j in range(len(nums)-k):
            # 滑动窗口移除最前面元素
            que.pop(nums[j])
            # 滑动窗口前加入最后面的元素
            que.push(nums[j+k])
            # 记录对应的最大值
            res.append(que.getMax())
        return res 
# 定义单调队列MyQueue，保持递减
from collections import deque
class MyQueue:
    def __init__(self):
        # 使用deque来实现单调队列
        self.queue = deque() 
    def pop(self,element):
        # 弹出之前判断要弹出的元素是否和队首元素相等，相等则弹出
        # 其他元素在push的时候该弹出就弹出了
        # 同时也要保住queue非空的前提下操作
        if self.queue and self.queue[0] == element:
            self.queue.popleft()
    # 如果push的数值大于入口元素的数值，那么就将队列后端的数值弹出，
    # 直到push的数值小于等于队列入口元素的数值为止。
    # 这样就保持了队列里的数值是单调从大到小的了。
    def push(self,element):
        while self.queue and self.queue[-1] 

2. 用list实现单调队列

# time:O(N);space:O(k)
class MyQueue: #单调队列（从大到小
    def __init__(self):
        self.queue = [] #使用list来实现单调队列
    
    #每次弹出的时候，比较当前要弹出的数值是否等于队列出口元素的数值，如果相等则弹出。
    #同时pop之前判断队列当前是否为空。
    def pop(self, value):
        if self.queue and value == self.queue[0]:
            self.queue.pop(0)#list.pop()时间复杂度为O(n),这里可以使用collections.deque()
            
    #如果push的数值大于入口元素的数值，那么就将队列后端的数值弹出，
    #直到push的数值小于等于队列入口元素的数值为止。
    #这样就保持了队列里的数值是单调从大到小的了。
    def push(self, value):
        while self.queue and value > self.queue[-1]:
            self.queue.pop()
        self.queue.append(value)
        
    #查询当前队列里的最大值 直接返回队列前端也就是front就可以了。
    def front(self):
        return self.queue[0]
    
class Solution:
    def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:
        que = MyQueue()
        result = []
        for i in range(k): #先将前k的元素放进队列
            que.push(nums[i])
        result.append(que.front()) #result 记录前k的元素的最大值
        for i in range(k, len(nums)):
            que.pop(nums[i - k]) #滑动窗口移除最前面元素
            que.push(nums[i]) #滑动窗口前加入最后面的元素
            result.append(que.front()) #记录对应的最大值
        return result

3. 复杂度分析

时间复杂度：O(N)

N为nums的长度，我们可能想了，在队列中 push元素的过程中，还有pop操作呢，感觉不是纯粹的O(n)，其实，可以自己观察一下单调队列的实现，nums 中的每个元素最多也就被 push_back 和 pop_back 各一次，没有任何多余操作，所以整体的复杂度还是 O(n)；

空间复杂度：O(K）

K为滑动窗口的大小，空间复杂度因为我们定义一个辅助队列，所以是O(k)。

4. 思考

1. 题解中单调队列里的pop和push接口，仅适用于本题。单调队列不是一成不变的，而是不同场景不同写法，总之要保证队列里单调递减或递增的原则，所以叫做单调队列。 不要以为本题中的单调队列实现就是固定的写法；
2. 关于deque，C++中deque是stack和queue默认的底层实现容器（这个我们之前已经讲过啦），deque是可以两边扩展的，而且deque里元素并不是严格的连续分布的；在Python中deque的丢掉左边元素为deque.popleft(); 丢掉右边元素为deque.pop();<不是deque.popright()>，然后获取队列头部为deque[0]；获取尾部为deque[-1]；尾部加上元素为deque.append(element)；头部加上元素为deque.appendleft(element)；
3. 队列的很有难度的应用了。

Reference： 代码随想录 (programmercarl.com)

本题学习时间：90分钟。

---

 LeetCode347. 前K个高频元素 

链接：347. 前 K 个高频元素 - 力扣（LeetCode）

1. 思路

这道题常规思路是这样的： 首先把元素及其频率存入字典中，key为元素，value为频率，然后以value为基准，对所有元素进行排序，时间复杂度为O(NlogN），然后输出前K个key值；分析知道，我们没有必要对所有元素进行排序，只需要维护K个有序集合就可以了。

这道题目主要涉及到如下三块内容：

1. 要统计元素出现频率
2. 对频率排序
3. 找出前K个高频元素

1. 统计元素出现的频率

首先统计元素出现的频率，这一类的问题可以使用map来进行统计。

2. 对频率排序

然后是对频率进行排序，这里我们可以使用一种 容器适配器就是优先级队列。

背景知识：什么是优先级队列呢？

其实就是一个披着队列外衣的堆，因为优先级队列对外接口只是从队头取元素，从队尾添加元素，再无其他取元素的方式，看起来就是一个队列。而且优先级队列内部元素是自动依照元素的权值排列。那么它是如何有序排列的呢？缺省情况下priority_queue利用max-heap（大顶堆）完成对元素的排序，这个大顶堆是以vector为表现形式的complete binary tree（完全二叉树）。

背景知识：什么是堆呢？

堆是一棵完全二叉树，树中每个结点的值都不小于（或不大于）其左右孩子的值。 如果父亲结点是大于等于左右孩子就是大顶堆，小于等于左右孩子就是小顶堆。

所以大家经常说的大顶堆（堆头是最大元素），小顶堆（堆头是最小元素），如果懒得自己实现的话，就直接用priority_queue（优先级队列）就可以了，底层实现都是一样的，从小到大排就是小顶堆，从大到小排就是大顶堆。本题我们就要使用优先级队列来对部分频率进行排序。

为什么不用各种排序方法呢？

为什么不用快排呢， 使用快排要将map转换为vector的结构，然后对整个数组进行排序， 而这种场景下，我们其实只需要维护k个有序的序列就可以了，在N非常大的时候，用优先级队列的优势会体现的非常明显，所以使用优先级队列是最优的。

此时要思考一下，是使用小顶堆呢，还是大顶堆？

有的同学一想，题目要求前 K 个高频元素，那么果断用大顶堆啊。那么问题来了，定义一个大小为k的大顶堆，在每次移动更新大顶堆的时候，每次弹出都把最大的元素弹出去了，那么怎么保留下来前K个高频元素呢。而且使用大顶堆就要把所有元素都进行排序，那能不能只排序k个元素呢？所以我们要用小顶堆，因为要统计最大前k个元素，只有小顶堆每次将最小的元素弹出，最后小顶堆里积累的才是前k个最大元素。

3. 找出前K个高频元素

倒叙优先级队列（小顶堆），然后输出结果。

Example

寻找前k个最大元素流程如图所示：（图中的频率只有三个，所以正好构成一个大小为3的小顶堆，如果频率更多一些，则用这个小顶堆进行扫描）

2. 代码实现

#时间复杂度：O(nlogk)
#空间复杂度：O(n)
import heapq
class Solution(object):
    def topKFrequent(self, nums, k):
        """
        :type nums: List[int]
        :type k: int
        :rtype: List[int]
        """
        # 统计元素出现频率
        record = {}  
        for item in nums:
            if item in record:
                record[item]  += 1
            else:
                record[item] = 1
        '''
        # 这也是一种创建record数组的方法
        for i in range(len(nums)):
            record[nums[i]] = record.get(nums[i],0) +1
        '''
       
        # 对频率排序，利用小顶堆
        minHeap = [] #小顶堆
        for key,freq in record.items():
						# 要把频率放在前面，因为小顶堆自动按照第一个元素排序
            heapq.heappush(minHeap,(freq,key))
            # 如果堆的大小大于了K，则队列弹出，保证堆的大小一直为K
            if len(minHeap) > k:
                heapq.heappop(minHeap)
        
        # 找出前K个高频元素，因为小顶堆先弹出的元素是最小的
        # 所以倒叙来输出数组
        result = [0]*k
        for i in range (k-1,-1,-1):
            result[i] = heapq.heappop(minHeap)[1]
        return result

3. 复杂度分析

时间复杂度：O(NlogK）

nums的长度为N，k 为输出前K个频率最高的数字；首先遍历nums，创建字典的时间复杂度为O(N），然后遍历字典中的pair，一个个push到小顶堆的中去，每个push的元素的时间复杂度为logK，因为小顶堆的底层实现就是二叉树，二叉树重新调整位置的复杂度为O(logK），然后如果大小超过K个的时候，就push一个进来，pop一个出去，pop的复杂度为O(1），所以这个过程的复杂度为O(NlogK), 最后遍历小顶堆然后倒叙输出结果的复杂度为O(K），总体来说复杂度为O（ NlogK）；

空间复杂度为：O(N）

要存一个大小为O(N)的字典，还要存一个大小为O(k）的小顶堆，总体来说空间复杂度为O(N）。

4. 思考

1. Python中的堆是heapq，在建立小顶堆的时候，先建立一个minHeap的list，然后用heapq.heappush(minHeap,(freq,key))把元素push进去，pop的方法是heapq.heappop(minHeap)，然后要把频率放在前面，因为小顶堆自动按照第一个元素排序；
2. 本题是 大数据中取前k值 的经典思路，大/小顶堆的应用，也算是优先级队列。

Reference：代码随想录 (programmercarl.com)

本题学习时间：60分钟。

---

PS：本篇学习所花时间为大约4小时，学习了一个栈的应用和队列中的单调队列和大小顶堆的优先级队列的应用，收获满满！