代码随想录LeetCode刷题第八天---------滑动窗口最大值

239. 滑动窗口最大值

给你一个整数数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。返回 滑动窗口中的最大值 。
输入：nums = [1,3,-1,-3,5,3,6,7], k = 3
输出：[3,3,5,5,6,7]

• 自己思路：栈和队列没想到比较好点的办法，就直接暴力，遍历数组，以k为大小，调用库函数Math.max找到最大值，先考虑的就是把这个值存入List当中，因为不知道比出来几个，然后把list转换成int[]，另一个思路就是知道求出来有几个数，通过规律判断出就是nums.length-k+1个值，所以也可以建立数组来存。
  思路一代码

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        List<Integer> a = new ArrayList<Integer>();
        for(int i=0;i<=nums.length-k;i++){
            int tmp=nums[i];
            for(int j=i;j+1<i+k;j++){
                tmp=Math.max(tmp,nums[j+1]);
            }
            a.add(tmp);
        }
           int[] b = new int[a.size()]; 
           int i = 0;
            for (int t : a) {
                b[i++] = t;
            }
          return b;
        
    }
   
}
//暴力代码超出时间限制

//return a.toArray(new Integer[a.size()]);

        // int[] ints = a.stream()
        //                 .mapToInt(i -> i)
        //                 .toArray();
        // return ints;

考虑是不是list转int[]，太费时，用思路2.

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        int[] b = new int[nums.length-k+1];
        for(int i=0;i<=nums.length-k;i++){
            int tmp=nums[i];
            for(int j=i;j+1<i+k;j++){
                tmp=Math.max(tmp,nums[j+1]);
            }
            b[i]=tmp;
        }        
          return b;      
    }
   
}

发现思路2也是超时，所以直接暴力不行。
deque使用详细讲解

deque各种方法
看完题解思路：

• 优先队列：把滑动窗口看成一个队列，然后移动后push前pop，为了得到这个队列的最大值，可以单调队列把它排序，但是那样的话，就改变了push和pop的顺序就不行
• 因此我们就自己定义一个单调队列，这个单调队列也是往前走pop前面push后面，但是队列里面维护的元素需要想一下，每次push，我们都只关心这k个里面最大的，push时如果队列现有的元素比要push进去的元素小，那就都删除，因为队列中没有必要维护这些值，并且还要保证当前队列中最大的值是第一个。如果队中的元素现在都比他大，那就不做删除操作，直接加在最后面。
  poll：队列需要前进，只有当要poll的值和当前队列最大值相等的时候才会poll，原因就是，其他的比他小的pop已经在add(push)的时候完成了，每push一个就和前面的比一次，小就加在后面，大就把前面比他小的都删了。其实每次都在poll，只不过当val不等于getFirst()也就是队列里的最大值的时候没有操作（因为add里已经操作过了）。
• 注：peek返回队首元素，队列中还存在这个元素。

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        if (nums.length == 1) {//为1的时候，写不写无所谓
            return nums;
        }
        int n=0;
        Mydeque my = new Mydeque();
        int[] res = new int[nums.length-k+1];
        for(int i=0;i<k;i++){
            my.add(nums[i]);
        }//1,3,1,2,1;k=3这就是 3,1
        res[n++]=my.peek();//res第一个元素3
        //首次需要这样做是因为首次不poll，所以单拿出来写
        for(int i=k;i<nums.length;i++){
        //for控制的i是下一个要push进队列的元素
            my.poll(nums[i-k]);//先pop后push
            my.add(nums[i]);
            res[n++]=my.peek();
        }
        return res;
    }
}
class Mydeque{
    Deque<Integer> a= new ArrayDeque<Integer>();//deque实现类
    void add(int val){
        while(!a.isEmpty()&&a.getLast()<val){
            a.removeLast();
        }
        a.addLast(val);
    }
    void poll(int val){
        if(!a.isEmpty()&&a.getFirst()==val){
            a.pollFirst();
        }
    }
    int peek(){
        return a.peekFirst();
    }
}

347. 前 K 个高频元素

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

示例 1:

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

• 思路：看完题没有思路，暴力好像也用不了

基本概念：

• 要先统计出每个元素出现的频率，然后给这个频率排序，最后取出前k个高的频率的元素
  计算元素出现的频率，用map，对频率排序就是优先级队列。优先级队列就是从队头取元素，从队尾添加元素，无其他取元素的方式，看起来就是一个队列，并且内部元素是自动依照元素的权值排列的，缺省情况下priority_queue利用max-heap（大顶堆）完成对元素的排序，这个大顶堆是以vector为表现形式的complete binary tree（完全二叉树）。
• 堆？大顶堆？小顶堆？
  堆是一棵完全二叉树，树中每个结点的值都不小于（或不大于）其左右孩子的值。 根结点大于等于孩子就是大顶堆，小于等于就是小顶堆。
  所以大家经常说的大顶堆（堆头是最大元素），小顶堆（堆头是最小元素），如果懒得自己实现的话，就直接用priority_queue（优先级队列）就可以了，底层实现都是一样的，从小到大排就是小顶堆，从大到小排就是大顶堆。

解题思路：

• map key中存元素，value存他出现的频率，利用优先级队列（底层小顶堆）按照value排序，最后输出key。小顶堆是因为，优先级队列内部排序方式是：大顶堆从最大的数开始，出队列是先从根节点开始弹出，所以直接把最大的弹出了，最后k中剩下的应该是最低频的元素。队列中应该一直维护k个高频元素，最后剩下的k个就是我们要的结果。所以构建小顶堆，把所有频率放在堆中，如果堆的大小大于K了，就从堆顶弹出，也就是说，当超过k个大小时每次都把频率最小的给弹出了。
• 这个题就用优先级队列来进行对部分频率的排序，因为我们只关心前K个。不用其他排序方法的是他们对整个数组进行排序， 我们其实只需要维护k个有序的序列就可以。