【算法day13】239. 滑动窗口最大值 347. 前 K 个高频元素

239.滑动窗口最大值

给你一个整数数组 nums，有一个大小为 k **的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 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

示例 2：

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

思路

需要自定义一个单调队列！！！

Java代码

public int[] maxSlidingWindow(int[] nums, int k) {
    MonotonicQueue mq = new MonotonicQueue();
    int l = nums.length - k + 1;//结果数组的长度
    int[] res = new int[l];//结果数组
    int index = 0;
    for(int i = 0; i < nums.length; i++) {
        if(i < k - 1) {
            mq.push(nums[i]);
        } else {
            mq.push(nums[i]);
            res[index++] = mq.max();//把窗口最大值记录下来
            mq.pop(nums[i-k+1]);//窗口第一个元素如果是最大元素就减去
        }
    }
    return res;
}
/**
 * 自定义单调队列  从大到小
 */
class MonotonicQueue {
    LinkedList<Integer> queue = new LinkedList<>();
    //入队【单调队列的关键】
    public void push(int e) {
        //如果队尾元素小于入队元素就删除，直至队尾元素不小于入队元素
        while (queue.size() != 0 && getLast() < e) {
            removeLast();
        }
        queue.add(e);
    }
    //出队
    public void pop(int t) {
        if(queue.size() != 0 && queue.getFirst() == t) {
            removeFirst();
        }
    }
    //删除第一个元素
    public int removeFirst() {
        return queue.removeFirst();
    }
    //删除最后的元素
    public int removeLast() {
        return queue.removeLast();
    }
    //得到最大元素
    public int max() {
        return getFirst();
    }
    //得到队首元素
    public int getFirst() {
        return queue.getFirst();
    }
    //得到队尾元素
    public int getLast() {
        return queue.getLast();
    }
}

347. 前 K 个高频元素

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

示例 1:

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

示例 2:

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

思路

需要借助 Java 里的优先队列:PriorityQueue

PriorityQueue 的底层实现是一个最小堆 ——— 其堆顶元素是权重最小的元素

Java代码

public int[] topKFrequent(int[] nums, int k) {
        Map<Integer,Integer> map = new HashMap<>();
        for(int num:nums){//将数组中的不同元素及其出现次数存到 HashMap
            map.put(num,map.getOrDefault(num,0)+1);
        }
        //优先队列【底层是一个最小堆】
        //每一个节点是一个两个数的数组 第一个数是元素值，第二个数是元素出现次数 当作键值对
        //k是初始容量
        //Comparator.comparingInt(pair -> pair[1]) 是权重排序规则 ：
        // 按照节点数组的第二个数字的值（元素出现次数）排序
        PriorityQueue<int[]> priorityQueue = new PriorityQueue<>(k, Comparator.comparingInt(pair -> pair[1]));
        for(Map.Entry<Integer,Integer> entry:map.entrySet()) {
            if(priorityQueue.size() < k) {//优先队列size小于 k 时，直接添加节点（键值对）
                priorityQueue.add(new int[]{entry.getKey(),entry.getValue()});
            }else {//如果后续的元素次数大于堆顶元素次数就添加进优先队列
                if(entry.getValue() > priorityQueue.peek()[1]) {
                    priorityQueue.poll();//删除堆顶元素
                    priorityQueue.add(new int[]{entry.getKey(),entry.getValue()});
                }
            }
        }
        int index = 0;
        int[] res = new int[k];
        //把优先队列的所有元素值存到数组然后返回
        for(int[] temp : priorityQueue) {
            res[index++] = temp[0];
        }
        return res;
    }