力扣239，347题，打卡第13天

今天是认真写博客的一天

239题：用了两种方法，当用暴力法解决的时候用到的是List，但是应该是每次在目标内的k的数太大了导致一个问题，就是每次排序都非常耗时，所以超时了，但是方法绝对是没问题的。代码如下：

    public int[] maxSlidingWindow(int[] nums, int k) {
        if (nums.length<k){
            Arrays.stream(nums).sorted();
            return new int[nums[nums.length-1]];
        }
        int [] a = new int[nums.length-k+1];
        List<Integer> temp = new ArrayList<>();
        for (int i=0;i<k;i++){
            temp.add(nums[i]);
        }
        for (int i=k;i<=nums.length-1;i++){
            a[i-k] = temp.stream().max(Integer::compare).get();
            temp.remove(0);
            temp.add(nums[i]);
        }
        a[a.length-1] = temp.stream().max(Integer::compare).get();
        return a;
    }

第二种方法是用类似小根堆的方式做的，维护一个有序的队列。具体过程是让这个队列按从大到小的顺序进行排列，当有小于当前队列队尾的就不让入队列，这样下来可以维护更少的数，且每次不用排序，只需要把队列的第一个元素排出即可代码如下：

    Deque<Integer> deque = new LinkedList<>();
    void poll(int val){
        if(!deque.isEmpty()&&val==deque.peek()){
            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;
        }
        MyQueue MyQueue = new MyQueue();
        int[] res = new int[nums.length-k+1];
        int num=0;
        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题也是两种方法，可以暴力，也可以取巧

暴力来看就是用一个map来实现，最后遍历整个map取最大的k个值即可

取巧的方法在于小根堆的创立，这里有一个Java内部的LinkList的实现类，然后让这个小根堆维护k个值，最后顺序取出即可代码如下：

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