力扣刷题之优先队列

队列"/>

力扣刷题之优先队列

前言：优先队列底层是由大根堆或小根堆数据结构实现的。

前K个高频元素

347. 前 K 个高频元素

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

示例 1:

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

示例 2:

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

题目解读：题目的要求是要我们找出在一个数组中找出k个出现频率最多的元素。

刚看到这个题目时候，直接冒出一个解决思路，就是利用桶排序的思想， 定义一个很大长度的数组，数组哪个位置有数，那就在哪个下标所在位置加一，然后排序，取出前k个最大值。

但是，如果利用这种思想来做题，直接大大浪费了很多的空间，还有一些没有必要的时间。

所有就引出了哈希表这个数据结构。我们可以把数组中出现的元素值作为哈希表的key值，然后出现的频率作为它的value，在遍历一遍数组之后，哈希表已经存储完毕了，再将哈希表进行排序，就可以得到前k个最大元素了。

public class Solution {public int[] topKFrequent(int[] nums, int k) {int[] ak = new int[k];int cnt = 0;HashMap<Integer, Integer> map = new HashMap<>();int len = nums.length;for (int i = 0; i < len; i++) {map.put(nums[i], map.getOrDefault(nums[i], 0) + 1);}// 根据哈希表的Value值进行的排序List<Map.Entry<Integer, Integer>> list = new ArrayList<>(map.entrySet());list.sort(Map.EntryparingByValue(Comparator.reverseOrder()));for (int i = 0; i < k; i++) {ak[cnt++] = list.get(i).getKey();}return ak;}
}

虽说这样就可以做完了，但是它的时间复杂度是O（n*k），我们并不满足如此，如果使用优先队列，我们就可以将时间复杂度减少到O（n*logk)。如果k越大，两者时间复杂度还会更大。

大根堆其实是一颗二叉树，是一颗二叉平衡树，它的根结点就是最大的数，左边结点会小于右边结点。

public class Solution {public int[] topKFrequent(int[] nums, int k) {int[] ak = new int[k];HashMap<Integer, Integer> map = new HashMap<>();//这里是大顶堆// PriorityQueue<int[]> pq = new PriorityQueue<>((pair1, pair2)->pair2[1]-pair1[1]);//小根堆PriorityQueue<int[]> pq = new PriorityQueue<>((pair1, pair2)->pair1[1]-pair2[1]);for(int num : nums){map.put(num, map.getOrDefault(num,0) +1);   //default}for(Map.Entry<Integer,Integer> entry : map.entrySet()){// pq.add(new int[]{entry.getKey(),entry.getValue()});if(pq.size()<k){//小顶堆元素个数小于k个时直接加pq.add(new int[]{entry.getKey(),entry.getValue()});}else{if(entry.getValue()>pq.peek()[1]){//当前元素出现次数大于小顶堆的根结点(这k个元素中出现次数最少的那个)pq.poll();//弹出队头(小顶堆的根结点),即把堆里出现次数最少的那个删除,留下的就是出现次数多的了pq.add(new int[]{entry.getKey(),entry.getValue()});}}}for(int i =k-1;i >=0 ;i--){ak[i] = pq.poll()[0];}return ak;}
}

滑动窗口最大值

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       31 [3  -1  -3] 5  3  6  7       31  3 [-1  -3  5] 3  6  7       51  3  -1 [-3  5  3] 6  7       51  3  -1  -3 [5  3  6] 7       61  3  -1  -3  5 [3  6  7]      7

示例 2：

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

 如果做完第一题，直接来做第二题的，肯定第一秒想到的是直接使用循环＋大根堆来实现，那真的能实现吗？we can try

class Solution {public int[] maxSlidingWindow(int[] nums, int k) {int cnt = 0;int len = nums.length;int[] ans = new int[len - k +1 ];for(int i=0;i <= len-k;i++){PriorityQueue<Integer> pq = new PriorityQueue(k, new Comparator<Integer>() {@Overridepublic int compare(Integer o1, Integer o2) {return o2pareTo(o1);}});;for(int j = i;j < i+k ; j++)pq.add(nums[j]);ans[cnt++] = pq.poll();}return ans;}
}

直接一整个时间超限了。

那这个题目要怎么来做呢？

class myQueue{Deque<Integer> deque = new LinkedList<>();void poll(int val){if(!deque.isEmpty() && deque.peek() == val)deque.poll();}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 cnt = 0;myQueue myQueue = new myQueue();//先将前k的元素放入队列for (int i = 0; i < k; i++) {myQueue.add(nums[i]);}res[cnt++] = myQueue.peek();for (int i = k; i < nums.length; i++) {//滑动窗口移除最前面的元素，移除是判断该元素是否放入队列myQueue.poll(nums[i - k]);//滑动窗口加入最后面的元素myQueue.add(nums[i]);//记录对应的最大值res[cnt++] = myQueue.peek();}return res;}
}