239. 滑动窗口最大值347.前 K 个高频元素

239. 滑动窗口最大值347.前 K 个高频元素

239. 滑动窗口最大值

力扣题目链接(opens new window)

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

返回滑动窗口中的最大值。

进阶：

你能在线性时间复杂度内解决此题吗？

提示：

• 1 <= nums.length <= 10^5
• -10^4 <= nums[i] <= 10^4
• 1 <= k <= nums.length

思路

思路：队列
相信看到这一题的第一眼，大多数人的思路是。遍历数组，找到滑动窗口的最大值并比较。那么我们分析下这种情况的时间复杂度
滑动窗口的大小为k，从滑动窗口找到最大元素的时间复杂度为o(k).滑动窗口的个数为n-k+1。那么总时间复杂度为o(k*(n-k+1)) = o(nk-k2+k) = o(nk).
这种思路很简单，很容易想到，但是这里不使用该思路.原因1.思路简单，容易想到2.据说会超出时间复杂度3,最重要的这里是要联系队列的使用方式4
不管哪种思路，都需要遍历一遍数组，那么时间复杂度至少是o(N)，这是毋庸置疑的，那么如何算法时间复杂度的提升，就在于求滑动窗口的最大值。
接下来介绍单调队列思路，
我们把队列当作窗口，窗口的移动会带来元素的变化，那么等同于队列的元素add，poll。
因为没有原生的方法可以以o(1)的时间复杂度获取队列中最大的元素。如果想以o(1)的时间复杂度获取队列中最大的元素，那就让每一个出队的元素就是窗口最大的元素，时间复杂度就是o(1)
但是一旦元素入队以后，顺序无法改变，所以需要自定义一个队列结构，并自定义poll和add方法。这个队列称为单调队列，当然单调队列的定义方式不是一成不变的，而是根据题目来定义的
add(value)：如果窗口移除的元素value等于单调队列的出口元素，那么队列弹出元素，否则不用任何操作
poll(value)：如果push的元素value大于入口元素的数值，那么就将队列入口的元素弹出，直到push元素的数值小于等于队列入口元素的数值为止
举例：数组元素 窗口大小为2

代码如下

//    时间复杂度: O(n)
//    空间复杂度: O(k)
    public static int[] maxSlidingWindow(int[] nums, int k) {
        MyQueueMaxSlidingWindow myQueue = new MyQueueMaxSlidingWindow();
        int[] result = new int[nums.length - k + 1];
        for (int i = 0; i < k; i++) {
            myQueue.add(nums[i]);
        }
        int t = 1;
        result[0] = myQueue.getMaxValue();
        for (int i = k; i < nums.length; i++) {
            myQueue.add(nums[i]);
            myQueue.poll(nums[i-k]);
            result[t++] = myQueue.getMaxValue();
        }
        return result;

    }

347.前 K 个高频元素

力扣题目链接(opens new window)

给定一个非空的整数数组，返回其中出现频率前 k 高的元素。

示例 1:

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

示例 2:

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

提示：

• 你可以假设给定的 k 总是合理的，且 1 ≤ k ≤ 数组中不相同的元素的个数。
• 你的算法的时间复杂度必须优于 $O(n\log n)$ , n 是数组的大小。
• 题目数据保证答案唯一，换句话说，数组中前 k 个高频元素的集合是唯一的。
• 你可以按任意顺序返回答案。

思路

思路：优先级队列
此题分为三个部分1.统计数字出现频率2.对频率排序3.获取出现频率前k的元素
根据题干信息，可以使用map哈希结构存储数字的出现频率。key为数字值，value为数字出现频率
遍历数组，将值存入Map中
接下来对Map排序。由于题目要求，最好时间复杂度在 O(n log n) ，其中 n 是数组大小。那么像快速排序等对【整个数组】排序的时间复杂度最少也要在n(logn)
所以另辟蹊径。采用堆排序。那么这个时候有人问了，那堆排序也是n(logn)时间复杂度啊。没错，但是我们定义堆的大小是K,那么时间复杂度就是n(logk)
那么要定义大顶堆还是小顶堆呢？
因为定义的堆大小是小于数组元素的，所以会对堆的元素频繁pop和push。如果用大顶堆，那么每次加入一个新的元素，就会把堆顶的元素，也就是最大的元素弹出。最后遍历完成后，堆中只有数组的小元素。
所以要使用小顶堆.
定义小顶堆可以使用优先级队列

java 优先队列默认是小顶堆，小的先出队。

PriorityQueue<Integer> pq = new PriorityQueue<>();

改成大的先出队：

PriorityQueue<Integer> pq = new PriorityQueue<>((a, b)->(b-a));

代码如下

// 时间复杂度o(nlogk)
// 空间复杂度o(n)
public static int[] topKFrequent(int[] nums, int k) {
    Map<Integer, Integer> map = new HashMap<>();
    for (int i = 0; i < nums.length; i++) {
        if (!map.containsKey(nums[i])) {
            map.put(nums[i], 1);
        } else {
            Integer value = map.get(nums[i]);
            map.put(nums[i], ++value);
        }
    }
    PriorityQueue<int[]> queue = new PriorityQueue<>((t1,t2) -> t1[1]-t2[1]);
    for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
        queue.add(new int[]{entry.getKey(), entry.getValue()});
        if (queue.size() > k) {
            queue.poll();
        }
    }
    int[] result = new int[k];
    for (int i = k - 1; i >= 0; i--) {
        int[] a = queue.poll();
        result[i] = a[0];
    }
    return result;