leetcode算法练习——239. 滑动窗口最大值 347.前K个高频元素

leetcode算法练习

239. 滑动窗口最大值

题目链接
单调队列：维护队列里 单调递增或递减 将有可能成为最大值的数放在队列

思路：

• push进来的元素比之前的都要大 那么前面的元素都要删除 直到前面的元素没有加入的元素大为止 弹出队首元素就是窗口最大值
• 如果滑动窗口向后移动 弹出元素和队首元素相同 就说明是当前窗口的最大值 要真pop掉

class MyQueue {
    Deque<Integer> deque = new LinkedList<>();
    // 弹出元素时 比较当前要弹出的数值是否等于队列出口的数值 如果相等则弹出
    // 同时判断队列当前是否为空
    void poll(int val) {
        if (!deque.isEmpty() && val == deque.peek()) {
            // 说明要移除的元素是滑动窗口里的最大值
            deque.poll();
        }
    }
    // 加入元素比队尾的元素都大 那么就将队尾元素进行弹出
    // 例如：5 2 1 0 要加入 3 那么0 1 2都弹出
    void add(int val) {
        while (!deque.isEmpty() && val > deque.getLast()) {
            deque.removeLast();
        }
        deque.add(val);
    }
    // 队列队顶元素始终为最大值
    int peek() {
        return deque.peek();
    }
}

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        if (nums.length == 1) {
            return nums;
        }
        int len = nums.length - k + 1;
        // 存放结果元素的数组
        int[] res = new int[len];
        int num = 0;
        // 自定义队列
        MyQueue myQueue = new MyQueue();
        // 先将前k的元素放入队列
        for (int i = 0; i < k; i++) {
            myQueue.add(nums[i]);
        }
        res[num++] = myQueue.peek();
        for (int i = k; i < nums.length; i++) {
            // 滑动窗口移除最前面的元素，移除是判断该元素是否放入队列
            myQueue.poll(nums[i - k]);
            // 滑动窗口加入最后面的元素
            myQueue.add(nums[i]);
            // 记录对应的最大值
            res[num++] = myQueue.peek();
        }
        return res;
    }
}

347.前K个高频元素

题目链接
一下子就联想到了map这种数据结构！
key存放数组内元素 value存放数组内元素出现的次数

思路：

• 对数组内元素先进行排序——可以根据value从大到小进行排序 然后取出前k个 对元素进行排序 快排时间复杂度是nlogn
• 但其实没必要对所有元素排序 因为只要维护前k个——利用大顶堆/小顶堆来实现
  堆底层的实现是二叉树：大顶堆就是头部元素比孩子元素大 小顶堆反之

如何利用堆来实现呢？
用堆去遍历map里的所有元素 堆里只要维持k个元素
选择使用哪个顶堆呢？

时间复杂度：遍历一遍数组内的元素为n 在堆内没加入一个元素 考虑到堆实现是二叉树 所以是logk的复杂度 因为堆只维护k个元素——故为nlogk

/* Comparator接口说明:
 * 返回负数，形参中第一个参数排在前面；返回正数，形参中第二个参数排在前面
 * 对于队列：排在前面意味着往队头靠
 * 对于堆（使用PriorityQueue实现）：从队头到队尾按从小到大排就是最小堆（小顶堆），
 *                                从队头到队尾按从大到小排就是最大堆（大顶堆）--->队头元素相当于堆的根节点
 * */
class Solution {
    public int[] topKFrequent(int[] nums, int k) {
        // 基于小顶堆实现
        // key为数组元素值 val为对应出现次数
        Map<Integer,Integer> map = new HashMap<>();
        // 遍历数组 统计频率
        for(int num:nums){
            // map.getOrDefault 如果存在key 则返回其对应的value并+1 如果不存在就返回0并+1
            map.put(num,map.getOrDefault(num,0)+1);
        }
        // 当一个方法需返回两个值并且两个值都有重要意义时 我们一般会用Map的key value来表达 但是如果仅返回两个值 就用管理一堆key/value键值对的HashMap等结构 有点大材小用 增加了数据结构的复杂度 选用pair
        // 创建小顶堆pq 里面存的是pair这种数据结构 即key value（key为数组元素值 val为对应出现次数）
        // 指定应该如何排序 要从小大到大 出现次数按从队头到队尾的顺序是从小到大排 出现次数最低的在队头(相当于小顶堆)
        PriorityQueue<int[]> pq = new PriorityQueue<>((pair1,pair2)->pair1[1]-pair2[1]);
        // 小顶堆只需要维持k个元素有序
        // 遍历map
        for(Map.Entry<Integer,Integer> entry:map.entrySet()){
            // 小顶堆元素个数小于k个时直接加
            if(pq.size() < k){
                pq.add(new int[]{entry.getKey(),entry.getValue()});
            }else{
                // 当前元素出现次数大于小顶堆的根结点(这k个元素中出现次数最少的那个)
                if(entry.getValue() > pq.peek()[1]){
                    // 弹出小顶堆的根结点 即把堆里出现次数最少的那个删除 留下的就是出现次数多的了
                    pq.poll();
                    // 存入现在的
                    pq.add(new int[]{entry.getKey(),entry.getValue()});
                }
            }
        }
        // 定义要返回的数组
        int[] ans = new int[k];
        // 倒序遍历 因为最高频的要先输出
        for(int i = k - 1; i >= 0; i--){
            // 依次弹出小顶堆 先弹出的是堆的根 出现次数少 后面弹出的出现次数多
            ans[i] = pq.poll()[0];
        }
        return ans;
    }
}