239. 滑动窗口最大值

输入：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       3
 1 [3  -1  -3] 5  3  6  7       3
 1  3 [-1  -3  5] 3  6  7       5
 1  3  -1 [-3  5  3] 6  7       5
 1  3  -1  -3 [5  3  6] 7       6
 1  3  -1  -3  5 [3  6  7]      7

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

方法一：暴力

思路：限定左右边界，每次计算边界中k个元素的最大值

复杂度分析：

• 时间复杂度: $O(nk)$

• 空间复杂度:$O(n)$

import java.util.ArrayList;
import java.util.List;

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        List<Integer> result = new ArrayList<>();
        // int[] result = new int[nums.length];
        int left =0;
        int right = left+k-1;

        while(right<nums.length ){
            int max1 = Integer.MIN_VALUE;
            for(int i =left; i<=right;i++){
                max1= Math.max(max1, nums[i]);
            }
            result.add(max1);

            left++;
            right++;
        }
        //方法一：List<Integer> 转 int[]
        int[] arr = new int[result.size()];
        for (int i = 0; i < result.size(); i++) {
            arr[i] = result.get(i);
        }

        //方法二：List<Integer> 转 int[]
        // int[] arr = list.stream().mapToInt(i -> i).toArray();
        return arr;
    }

    public static void main(String[] args) {
        Solution solution = new Solution();
//        int[] nums={1,3,-1,-3,5,3,6,7};
//        int[] nums={1,-1};
        int[] nums={1};
        int[] a= solution.maxSlidingWindow(nums,1);
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i]+" ");
        }
    }
}

leetcode上超出时间限制，虽然但是写出这个暴力也是磕磕绊绊，还需要debug。

方法二：单调队列

思路：利用双端队列手动实现单调队列

还是不太理解，和暴力基本一个思路，就是使用数据结构不一样，关于如何维护有序，不太理解，队列存的是nums的下标。

关于队头结点的下标范围，以例子int[] nums={1,3,-1,-3,5,3,6,7},k=3

i从0开始， nums.length-1结束，这个是用来遍历的，遍历nums的每个元素；

队头结点需要在[i - k + 1, i]范围内，也就是[i-2,i]，那么i怎么也得是2的时候，这个范围才是正常的。方法一的思路是[i,i+k-1]。

补充：

ArrayDeque<Integer> 是 Java 中的一种双端队列（deque）数据结构，也被称为数组双端队列。它是使用数组实现的双端队列，可以在队列两端进行高效的插入和删除操作。和上次的Deque<Character>双端队列很像，

deque相关：

1. deque.peek(): 这个函数返回双端队列（即deque）的头部元素，但不会将其从队列中移除。在代码中，deque.peek()用于获取队列头部指针对应的值，即获取队列中最大元素的下标。
2. deque.poll(): 这个函数从双端队列（即deque）的头部移除并返回一个元素。在代码中，deque.poll()用于移除队列头部指针对应的元素，即移除队列中的最大元素的下标。
3. deque.peekLast(): 这个函数返回双端队列（即deque）的尾部元素，但不会将其从队列中移除。在代码中，deque.peekLast()用于获取队列尾部指针对应的值，即获取队列中当前窗口内的最大元素。
4. deque.pollLast(): 这个函数从双端队列（即deque）的尾部移除并返回一个元素。在代码中，deque.pollLast()用于移除队列尾部指针对应的元素，即移除队列中当前窗口内的最大元素的下标。
5. deque.offer(i): 这个函数将指定的元素插入双端队列（即deque）的尾部。在代码中，deque.offer(i)用于将当前元素的下标i插入到队列中，以维护一个单调递减的队列。这样可以确保队列中的元素按照从大到小的顺序排列。

复杂度分析：

• 时间复杂度: $O(n)$

• 空间复杂度:$O(n)$

//解法二
//利用双端队列手动实现单调队列

import java.util.ArrayDeque;

/**
 * 用一个单调队列来存储对应的下标，每当窗口滑动的时候，直接取队列的头部指针对应的值放入结果集即可
 * 单调队列类似 （tail -->） 3 --> 2 --> 1 --> 0 (--> head) (右边为头结点，元素存的是下标)
 */
class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        ArrayDeque<Integer> deque = new ArrayDeque<>();
        int n = nums.length;
        int[] res = new int[n - k + 1];
        int idx = 0;
        for(int i = 0; i < n; i++) {
            // 根据题意，i为nums下标，是要在[i - k + 1, i] 中选到最大值，只需要保证两点
            // 1.队列头结点需要在[i - k + 1, i]范围内，不符合则要弹出
            while(!deque.isEmpty() && deque.peek() < i - k + 1){//deque有值 且 deque头部元素小于有边界（就是在k范围内）
                deque.poll();//移除头部元素
            }
            // 2.既然是单调，就要保证每次放进去的数字要比末尾的都大，否则也弹出
            while(!deque.isEmpty() && nums[deque.peekLast()] < nums[i]) {
                deque.pollLast();//移除尾部元素
            }

            deque.offer(i);//将元素插入尾部

            // 因为单调，当i增长到符合第一个k范围的时候，每滑动一步都将队列头节点放入结果就行了
            if(i >= k - 1){
                res[idx++] = nums[deque.peek()];
            }
        }
        return res;
    }
    public static void main(String[] args) {
        Solution solution = new Solution();
        int[] nums={1,3,-1,-3,5,3,6,7};
//        int[] nums={1,-1};
//        int[] nums={1};
        int[] a= solution.maxSlidingWindow(nums,3);
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i]+" ");
        }
    }
}

347. 前 K 个高频元素

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

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

方法一：基于大顶堆实现

思路：能想到map，但是不会写

复杂度分析：

• 时间复杂度: $O(logn)$

• 空间复杂度:$O(logn)$

import java.util.HashMap;
import java.util.Map;
import java.util.PriorityQueue;

class Solution {
    public int[] topKFrequent(int[] nums, int k) {

        Map<Integer,Integer> map = new HashMap<>();//key为数组元素值,val为对应出现次数
        for(int num:nums){
            map.put(num,map.getOrDefault(num,0)+1);//map.getOrDefault(num,0):当map中存在num的键，则返回对应值，否则返回0；
        }
        //在优先队列中存储二元组(num,cnt),cnt表示元素值num在数组中的出现次数
        //出现次数按从队头到队尾的顺序是从大到小排,出现次数最多的在队头(相当于大顶堆)
        PriorityQueue<int[]> pq = new PriorityQueue<>((pair1, pair2)->pair2[1]-pair1[1]);
        for(Map.Entry<Integer,Integer> entry:map.entrySet()){//大顶堆需要对所有元素进行排序
            pq.add(new int[]{entry.getKey(),entry.getValue()});
        }
        int[] ans = new int[k];
        for(int i=0;i<k;i++){//依次从队头弹出k个,就是出现频率前k高的元素
            ans[i] = pq.poll()[0];
        }
        return ans;
    }

    public static void main(String[] args) {
        int[] nums={1,1,1,2,2,3};
        Solution solution = new Solution();
        solution.topKFrequent(nums,3);
    }
}

补充：

map：

1. map.getOrDefault(num,0):当map中存在num的键，则返回对应值，否则返回0；
2. map.put(key,value)向map中添加键值对
3. map.put(num,map.getOrDefault(num,0)+1);则统计了一个数组nums的出现数字的频率，频率作为value存进了map

PriorityQueue

PriorityQueue<int[]> pq = new PriorityQueue<>((pair1, pair2)->pair2[1]-pair1[1]);创建了一个int数组的优先队列PriorityQueue，并使用lambda表达式定义了一个比较器，用于根据数组中第二个元素的大小来比较两个元素。

参数 (pair1, pair2) -> pair2[1] - pair1[1] 表示一个比较器，该比较器定义了两个数组 pair1 和 pair2 的比较方式。具体规则是：如果 pair1 中第二个元素小于 pair2 中的第二个元素，则 pair2 大于 pair1，返回正数；如果 pair1 中第二个元素等于 pair2 中的第二个元素，则它们相等，返回0；如果 pair1 中第二个元素大于 pair2 中的第二个元素，则 pair1 大于 pair2，返回负数。

根据比较器的规则，优先队列中的元素会按照第二个元素的大小进行排序，即第二个元素越大的数组在队列中越靠前。这里可以理解为map的键，也就是元素出现的频次，从高到低。