代码随想录算法训练营Day12|347.前 K 个高频元素、 239. 滑动窗口最大值

347.前 K 个高频元素

法一：
1、遍历数组，用map存储每个数字出现的次数
2、创建存储map中Entry的ArrayList
3、Collections.sort对Entry的值，也就是每个数字出现的次数排序
4、取出ArrayList集合中排名前k个的Entry的键

class Solution {
    public int[] topKFrequent(int[] nums, int k) {
       HashMap<Integer,Integer> map = new HashMap<Integer,Integer>();
       for(int num:nums){
            map.put(num,map.getOrDefault(num,0)+1);
       }
       List<Map.Entry<Integer,Integer>> list = new ArrayList<>(map.entrySet());
       Collections.sort(list,(a,b)->{
         return b.getValue()-a.getValue();
       });
       int[] res = new int[k];
        for(int i=0;i < k;i++){
            res[i] = list.get(i).getKey();
        }
        return res;
    }
}

法二：
1、方法一中需要创建一个长度为n的ArrayList存储Entry,但是最终我们只要前k个值，显然在空间上是有浪费的，所以想到用小顶堆解决这个问题。
2、小顶堆维持了一个最多只有k个元素的堆，这个堆在java中可以用一个实现了Queue接口的PriorityQueue对象去模拟。堆中的元素是按照值升序排列的。
3、如果堆中的值的个数不满k个，直接加入Entry，如果正好k个，每次加入一个都会将堆中最小的那个值弹出，从而保证堆中的k个元素使所有当前已经遍历的值中的前k个。
4、当全部遍历完毕，堆中的元素是所有元素中前k个大。

PriorityQueue原理：
1、是一个基于优先级的队列，它使用了一个优先队列算法（通常是堆结构）来保证队列头部（peek或poll方法返回的对象）总是队列中具有最高优先级的对象。在PriorityQueue中，元素的优先级由比较器（Comparator）决定，如果没有显式提供比较器，则使用元素的自然顺序。
2、当创建一个PriorityQueue并提供一个lambda表达式作为比较器时：
PriorityQueue<Map.Entry<Integer,Integer>> queue = new PriorityQueue<>((entry1, entry2) -> entry1.getValue() - entry2.getValue());
这会根据entry的值（即getValue()的结果）来排序队列。PriorityQueue内部会管理这个排序，所以每次调用peek或poll方法时，都会返回具有最高优先级（即值最大的）元素。
3、 PriorityQueue<Map.Entry<Integer,Integer>> queue = new PriorityQueue<>((entry1,entry2)->{return entry1.getValue()-entry2.getValue();});可以省略return语句，写成 PriorityQueue<Map.Entry<Integer,Integer>> queue = new PriorityQueue<>((entry1,entry2)->entry1.getValue()-entry2.getValue()）；

而PriorityQueue和LinkedList都是实现了Queue接口的集合类，但LinkedList不提供排序功能。

完整代码如下：

class Solution {
    public int[] topKFrequent(int[] nums, int k) {
        HashMap<Integer,Integer> map = new HashMap<Integer,Integer>();
        for(int num:nums){
            map.put(num,map.getOrDefault(num,0)+1);
        }
        PriorityQueue<Map.Entry<Integer,Integer>> queue =  new PriorityQueue<>((entry1,entry2)->{return entry1.getValue()-entry2.getValue();}
        );
        // PriorityQueue<Map.Entry<Integer,Integer>> pq = new PriorityQueue<>((a, b) -> a.getValue() - b.getValue());
        for(Map.Entry<Integer,Integer> entry:map.entrySet()){
            if(queue.size() < k){
                queue.add(entry);
            }else if(queue.peek().getValue() < entry.getValue()){
                queue.poll();
                queue.add(entry);
            }
        }
        int[] res = new int[k];
        for(int i = k-1;i>=0;i--){
            res[i] = queue.poll().getKey();
        }
        return res;
    }
}

239. 滑动窗口最大值

方法一：
暴力解法超时

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        ArrayList list = new ArrayList();
        int startindex = 0;
        int endindex = k-1;
        while(endindex < nums.length){
            int res = nums[startindex];
            for(int i = startindex;i <= endindex;i++){
                if(nums[i]>res){
                    res = nums[i];
                }
            }
            list.add(res);
            startindex++;
            endindex++;
        }
        int[] resInt = new int[list.size()];
        for(int i = 0;i < list.size();i++){
            resInt[i] = (int)list.get(i);
        }
        return resInt;
    }
}

法二
这个方法在队列中存的是nums中每个元素对应的索引，要保持队列中的元素是单调递减，每次nums遍历到新的元素nums[i]只需要满足两个条件即可：
1、队列头的索引值要在[i-k+1,i]之间
2、队列尾部的索引值对应的值要小于nums[i]

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        if(nums.length < k) return null;
        int[] res = new int[nums.length - k + 1];
        int j = 0;
        LinkedList<Integer> queue = new LinkedList<Integer>();
        //要保证在[i-k+1,i]中取得最大值，就要保证两点：
        //1、队列的头结点要在[i-k+1,i]范围中，不在说明已经超出了视线范围
        for(int i = 0;i < nums.length;i++){
            while(!queue.isEmpty() && queue.peek() < i-k+1){
                queue.poll();
            }
        //2、放入队列的数必须要大于队列尾部的数，否则弹出队列尾部的数
            while(!queue.isEmpty() && nums[queue.peekLast()] < nums[i]){
                queue.pollLast();
            }
            //加入的是索引
            queue.offer(i);
            //当i >= k-1才需要往结果数组中存数
            if(i >= k-1){
                res[j] = nums[queue.peek()];
                //这是j++要注意
                j++;
            }
        }     
        return res;
    }
}

法三
这是卡哥的方法，时间复杂度为O(n)

class Solution { 
    public int[] maxSlidingWindow(int[] nums, int k) {
        int[] res = new int[nums.length-k+1];
        Myqueu que = new Myqueu();
        int j = 0;
        for(int i = 0;i < k;i++){
            que.offer(nums[i]);
        }
        res[j++] = que.peek();
        for(int i = k;i < nums.length;i++){
            que.poll(nums[i-k]);
            que.offer(nums[i]);
            res[j++] = que.peek();
        }
        return res;
    }
}
class Myqueu{
    LinkedList<Integer> queue = new LinkedList<>();
    public void poll(int val){
        //判断此时poll的数是否是真正被滑动窗口遗弃的那个数，因为目前将被滑动窗口遗弃的那个数已经被前面的大值给卷走了，
        //但是大的那个值还没到要被滑动窗口遗弃的时候
        //如果一样就弹出，如果不一样不做任何操作
        if(!queue.isEmpty() && val == queue.peek()){
            queue.poll();
        }
    }
    //offer方法要判断queue入口处的值是否大于要加入的值，所有比要加入的值小的数都要先被弹出，以保证queue单调递减
    public void offer(int val){
        while(!queue.isEmpty() && queue.peekLast() < val){
            queue.pollLast();
        }
        queue.offer(val);
    }
    public int peek(){
        return queue.peek();
    }
}