day 13|第五章 栈与队列part03 ● 239. 滑动窗口最大值● 347.前 K 个高频元素● 总结

● 239. 滑动窗口最大值（似懂非懂）

有点似懂非懂的感觉

一开始不明白pop（）操作，现在有点明白了，因为你双端队列里面的队首始终是滑动窗口最大值，只要你滑动窗口始终有这个值，那么就不会把它pop掉，一旦滑动窗口的下一步，马上就要移走了，要移除的值与队首元素相同，那么就pop（）。

卡尔是自定义了一个单调队列，觉得有点麻烦，思路感觉还行，不算难，leetcode找了一个答案

之后再理解理解。看看左程云的也行，虽然他用的是数组

这是卡尔的答案：一开始没理解，现在有点理解了。

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        ArrayDeque<Integer> deque = new ArrayDeque<>();
        int n = nums.length;
        int[] res = new int[n - k + 1];
        int idx = 0;
        for(int i = 0; i < n; i++) {
            // 根据题意，i为nums下标，是要在[i - k + 1, i] 中选到最大值，只需要保证两点
            // 1.队列头结点需要在[i - k + 1, i]范围内，不符合则要弹出
            while(!deque.isEmpty() && deque.peek() < i - k + 1){
                deque.poll();
            }
            // 2.既然是单调，就要保证每次放进去的数字要比末尾的都大，否则也弹出
            while(!deque.isEmpty() && nums[deque.peekLast()] < nums[i]) {
                deque.pollLast();
            }

            deque.offer(i);

            // 因为单调，当i增长到符合第一个k范围的时候，每滑动一步都将队列头节点放入结果就行了
            if(i >= k - 1){
                res[idx++] = nums[deque.peek()];
            }
        }
        return res;
    }
}

这是leetcode找的答案：

class Solution {

	public static int[] maxSlidingWindow(int[] arr, int k) {
        Deque<Integer> deque = new LinkedList<>();
		int n = arr.length;
        int[] res = new int[n - k + 1];//答案数组

		// 先形成长度为k-1的窗口
		for (int i = 0; i < n; i++) {
             // 保证从大到小 如果前面数小则需要依次弹出，直至满足要求
			while(!deque.isEmpty()&&arr[deque.peekLast()]<=arr[i]){
                deque.pollLast();
            }
             // 添加当前值对应的数组下标
            deque.offerLast(i);
            if(deque.peekFirst()<= i-k){//[L,R]实际上就是[i+1-k,i]，判断队首元素的位置是否小于L，之前的写法不容易理解，// 判断当前队列中队首的值是否有效
                deque.pollFirst();
            }
            if(i+1 >= k){// 当窗口长度为k时 保存当前窗口中最大
                res[i+1-k] = arr[deque.peekFirst()];
            }
		}
        return res;
	}

}

● 347.前 K 个高频元素（堆）

需要用到堆这种数据结构，大根堆和小根堆之前还学了，现在有点儿忘了。

java中一般使用优先级队列，因为其就是由堆实现的

【Java】PriorityQueue--优先级队列_java priorityqueue-CSDN博客

Java 优先级队列_java优先级队列-CSDN博客

下面这是卡尔的代码，思路不算特别难，但是调用java里面的集合，以及对应的函数，还需要掌握。

class Solution {
    public int[] topKFrequent(int[] nums, int k) {
        // 优先级队列，为了避免复杂 api 操作，pq 存储数组
        // lambda 表达式设置优先级队列从大到小存储 o1 - o2 为从小到大，o2 - o1 反之
        PriorityQueue<int[]> pq = new PriorityQueue<>((o1, o2) -> o1[1] - o2[1]);
        int[] res = new int[k]; // 答案数组为 k 个元素
        Map<Integer, Integer> map = new HashMap<>(); // 记录元素出现次数
        for (int num : nums) map.put(num, map.getOrDefault(num, 0) + 1);
        for (var x : map.entrySet()) { // entrySet 获取 k-v Set 集合
            // 将 kv 转化成数组
            int[] tmp = new int[2];
            tmp[0] = x.getKey();
            tmp[1] = x.getValue();
            pq.offer(tmp);
            // 下面的代码是根据小根堆实现的，我只保留优先队列的最后的k个，只要超出了k我就将最小的弹出，剩余的k个就是答案
            if(pq.size() > k) {
                pq.poll();
            }
        }
        for (int i = 0; i < k; i++) {
            res[i] = pq.poll()[0]; // 获取优先队列里的元素
        }
        return res;
    }
}