13-算法训练营第十三天 | 力扣239滑动窗口最大值、力扣347前K个高频元素

力扣239：滑动窗口最大值

题目链接:力扣239：滑动窗口最大值

---

思路：

1.定义一个双端队列，队头用于弹出最大元素
2.将前k个元素进行遍历，并添加到队列中
3.从k+1个元素开始遍历到最后一个元素
4.判断下标为0的元素是否等于队头元素，如果等于，则需要移除队头元素
5.将当前元素依次与队尾元素进行比较，如果比队尾元素大，则移除掉队尾元素

---

代码：

class Solution {
        public int[] maxSlidingWindow(int[] nums, int k) {
            if (nums.length == 0 || k == 0) {
                return new int[0];
            }
            // 1.定义一个双端队列，队头用于弹出最大元素
            Deque<Integer> deque = new LinkedList<>();

            int[] result = new int[nums.length - k + 1];
            
            // 2.将前k个元素进行遍历，并添加到队列中
            for (int i = 0; i < k; i++) {
                while (!deque.isEmpty() && nums[i] > deque.peekLast()) {
                    deque.pollLast();
                }
                deque.offerLast(nums[i]);
            }
            
            result[0] = deque.peekFirst();

            // 3.从k+1个元素开始遍历到最后一个元素
            for (int i = k; i < nums.length; i++) {
                // 4.判断下标为0的元素是否等于队头元素，如果等于，则需要移除队头元素
                if (nums[i - k] == deque.peekFirst()) {
                    deque.pollFirst();
                }
                // 5.将当前元素依次与队尾元素进行比较，如果比队尾元素大，则移除掉队尾元素
                while (!deque.isEmpty() && nums[i] > deque.peekLast()) {
                    deque.pollLast();
                }
                deque.offerLast(nums[i]);
                result[i - k + 1] = deque.peekFirst();
            }
            
            return result;
        }
    }

---

力扣347：前K个高频元素

题目链接:力扣347：前K个高频元素

---

思路：

1.将数组中的元素及频率添加到map集合中
2.定义一个优先级队列(小顶堆)，存放数组元素(new int[]{num, count})
3.遍历map集合中的元素
4.如果元素出现频率比队头元素值大，则弹出队头元素；否则添加到队尾中
5.历优先级队列，弹出前k个元素返回即可

---

代码：

class Solution {
    public int[] topKFrequent(int[] nums, int k) {
        // 1.将数组中的元素及频率添加到map集合中
        Map<Integer, Integer> map = new HashMap<>();
        for (int num : nums) {
            map.put(num, map.getOrDefault(num, 0) + 1);
        }

        // 2.定义一个优先级队列(小顶堆)，存放数组元素(new int[]{num, count})
        PriorityQueue<int[]> priorityQueue = new PriorityQueue<>(new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                return o1[1] - o2[1];
            }
        });

        // 3.遍历map集合中的元素
        for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
            // 4.如果元素出现频率比队头元素值大，则弹出队头元素；否则添加到队尾中
            if (priorityQueue.size() < k) {
                priorityQueue.add(new int[] {entry.getKey(), entry.getValue()}); 
            } else {
                if (entry.getValue() > priorityQueue.peek()[1]) {
                    priorityQueue.poll();
                    priorityQueue.add(new int[] {entry.getKey(), entry.getValue()});
                }
            }
        }

        // 5.遍历优先级队列，弹出前k个元素返回即可
        int[] result = new int[k];
        for (int i = k - 1; i >= 0; i--) {
            result[i] = priorityQueue.poll()[0];
        }

        return result;
    }

}

---