代码随想录算法训练营第十三天 | 239. 滑动窗口最大值、347.前 K 个高频元素

学习目标

• 完成二分查找和移除元素相关题目

---

学习内容

239. 滑动窗口最大值(Hard)

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

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

示例 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]

思路：坦率地说，Hard 的题目，没有经过训练的话，基本是没有思路的。这里照用单调队列的思路。
时间复杂度：O(n) 空间复杂度：O(n)

解决方案：

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        Deque<Integer> deque = new ArrayDeque<>();
        int[] ans = new int[nums.length - k + 1];

        for(int left = 0, right = 0; right < nums.length; right ++) {
            if (!deque.isEmpty() && left > deque.peekFirst()) {
                deque.pollFirst();
            }
            while(!deque.isEmpty() && nums[right] > nums[deque.peekLast()]) {
                deque.pollLast();
            }
            deque.offerLast(right);
            if (left + right >= k - 1) {
                ans[left++] = nums[deque.peekFirst()];
            }
        }

        return ans;
    }
}

小结：
创建的是双端队列，方便操作，但是是当做单调队列来用。双端队列存储的是目标值对应的下标，目的还是方便操作。
算法的原则是：

• 队列中最左边的元素一定是当前窗口最大的元素，因此会有：

while(!deque.isEmpty() && nums[right] > nums[deque.peekLast()]) {
	deque.pollLast();
}
deque.offerLast(right);

即保证窗口移动后，队列中最左边的元素一定是当前窗口最大的元素。不过，窗口移动也可能会把队列中最左边的元素弹出，但由于上面的操作，我们不能明确知道队列中最左边的元素一定是窗口要弹出的元素，因此有下面的判断：

if (!deque.isEmpty() && left > deque.peekFirst()) {
	deque.pollFirst();
}

当处理完上面的操作后，就是要记录当前窗口的最大值了，不过要先确认窗口中的元素已经是 k 个了：

if (left + right >= k - 1) {
	ans[left++] = nums[deque.peekFirst()];
}

347.前 K 个高频元素(Middle)

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

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

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

思路：top k 问题应该要去想大顶堆
时间复杂度：O(nlogn) 空间复杂度：O(n)

解决方案：

class Solution {
    public int[] topKFrequent(int[] nums, int k) {
        Map<Integer,Integer> map = new HashMap<>();
        for(int n : nums) {
            map.put(n, map.getOrDefault(n, 0) + 1);
        }
        
        PriorityQueue<Map.Entry<Integer, Integer>> priorityQueue = 
        			new PriorityQueue<>((o1,o2)->o2.getValue() - o1.getValue());
        
        for(Map.Entry<Integer, Integer> entry : map.entrySet()) {
            priorityQueue.add(entry);
        }
        int[] ans = new int[k];
        for(int i = 0; i < k; i++) {
            ans[i] = priorityQueue.poll().getKey();
        }

        return ans;
    }
}

小结：这里

PriorityQueue<Map.Entry<Integer, Integer>> priorityQueue = 
				new PriorityQueue<>((o1,o2)->o2.getValue() - o1.getValue());

就是创建大顶堆。

---

总结

• 单独栈/队列问题很复杂，需要多练习；
• top k 问题应该要去想大顶堆