leetcode 剑指offer59-I：滑动窗口的最大值

题目描述：
给定一个数组 nums 和滑动窗口的大小 k，请找出所有滑动窗口里的最大值。
示例:
输入: 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

提示：
你可以假设 k 总是有效的，在输入数组不为空的情况下，1 ≤ k ≤ 输入数组的大小。

思路1： 暴力求解 每一次改变窗口内的值之后，进行一次排序返回最大值，时间复杂度较高：

class Solution:
    def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:
        if not nums:
            return []
        res, window = [], []
        i, j = 0, k-1
        while j < len(nums):
            window = nums[i:j+1]
            res.append(max(window))
            i += 1
            j += 1
        return res

思路2： 单调队列
利用一个辅助队列完成，窗口对应的数据结构为 双端队列 ，本题使用 单调队列 即可解决以上问题。遍历数组时，每轮保证单调队列 deque ：
deque 内 仅包含窗口内的元素 ⇒ 每轮窗口滑动移除了元素 nums[i−1] ，需将 deque 内的对应元素一起删除。
deque 内的元素 非严格递减⇒ 每轮窗口滑动添加了元素 nums[j+1] ，需将 deque 内所有 <nums[j+1] 的元素删除。
这样就可以保证队列的第一个元素一直是当前窗口的最大值。

import collections
from typing import List
class Solution:
    def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:
        # 使用一个队列完成
        if not nums or k == 0:
            return []
        res = []
        deque = collections.deque()
        for i in range(k):   # 还没有形成窗口时队列的样子
            while deque and deque[-1] < nums[i]:
                deque.pop()
            deque.append(nums[i])
        res.append(deque[0])
        for i in range(k, len(nums)):  # 形成窗口后，对队列进行处理，以使得队列的头一直是最大值
            if nums[i-k] == deque[0]:
                deque.popleft()
            while deque and deque[-1] < nums[i]:
                deque.pop()
            deque.append(nums[i])
            res.append(deque[0])
        return res

这个思路一定要记下来
与这个题思路相同的剑指offer 59-II：链接
使用单调队列实现可以直接返回最大值的队列。

import collections
class MaxQueue:

    def __init__(self):
        self.queue = []
        self.deque = collections.deque()


    def max_value(self) -> int:
        if not self.queue:
            return -1
        return self.deque[0]


    def push_back(self, value: int) -> None:
        self.queue.append(value)
        while self.deque and value > self.deque[-1]:
            self.deque.pop()
        self.deque.append(value)


    def pop_front(self) -> int:
        if not self.queue:
            return -1
        v = self.queue.pop(0)
        if v == self.deque[0]:
            self.deque.popleft()
        return v

与这个类似的问题：剑指offer30： 链接
使用一个单调栈完成最小值：

class MinStack:

    def __init__(self):
        """
        initialize your data structure here.
        """
        self.list1 = []
        self.min_list = []
        

    def push(self, x: int) -> None:
        if not self.list1:
            self.min_list.append(x)
        else:
            if self.min_list[-1] > x:
                self.min_list.append(x)
            else:
                self.min_list.append(self.min_list[-1])
        self.list1.append(x)
        return


    def pop(self) -> None:
        self.list1.pop()
        self.min_list.pop()
        return


    def top(self) -> int:
        return self.list1[-1]


    def min(self) -> int:
        return self.min_list[-1]