🔥 个人主页: 黑洞晓威
😀你不必等到非常厉害，才敢开始，你需要开始，才会变的非常厉害。

滑动窗口最大值

给定一个数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。

返回滑动窗口中的最大值。

问题分析

我们首先来分析滑动窗口最大值问题的输入、输出和约束条件：

• 输入：给定一个整数数组 nums 和一个正整数 k，数组长度为 n。
• 输出：返回一个数组，包含每个窗口的最大值。
• 约束条件：滑动窗口大小 k 保证小于或等于数组长度 n。

算法思路

解决滑动窗口最大值问题的一般思路如下：

• 首先，我们可以使用暴力解法，即对于每个窗口，遍历窗口中的所有元素并找到最大值。但这种方法的时间复杂度为 O(nk)，不够高效。
• 优化的算法思路是使用双端队列（deque）。我们维护一个双端队列，用来存储当前窗口中的元素下标。在遍历数组过程中，我们保持队列中的元素按照从大到小的顺序排列。这样，窗口的最大值就总是队列的第一个元素。

public class SlidingWindowMaximum {

    public static int[] maxSlidingWindow(int[] nums, int k) {
        if (nums == null || nums.length == 0 || k <= 0)
            return new int[0];

        int n = nums.length;
        int[] result = new int[n - k + 1]; // 结果数组长度为原数组长度减去窗口大小加一
        Deque<Integer> window = new ArrayDeque<>(); // 使用双端队列存储窗口中的元素下标

        for (int i = 0; i < n; i++) {
            // 移除窗口外的元素
            if (!window.isEmpty() && window.peek() < i - k + 1)
                window.poll();

            // 移除队列中比当前元素小的元素，确保队列中的元素按从大到小排序
            while (!window.isEmpty() && nums[window.peekLast()] < nums[i])
                window.pollLast();

            window.offer(i); // 将当前元素的下标加入队列

            // 当窗口满足大小时，记录最大值
            if (i >= k - 1)
                result[i - k + 1] = nums[window.peek()];
        }

        return result;
    }

    public static void main(String[] args) {
        int[] nums = {1, 3, -1, -3, 5, 3, 6, 7};
        int k = 3;
        int[] result = maxSlidingWindow(nums, k);

        // 输出结果
        System.out.print("滑动窗口最大值：");
        for (int num : result) {
            System.out.print(num + " ");
        }
        // Output: 滑动窗口最大值：3 3 5 5 6 7
    }
}

最大值

问题分析

我们首先分析了问题的输入、输出和约束条件：

• 输入：给定一个非空的整数数组 nums 和一个正整数 k。
• 输出：返回出现频率前 k 高的元素的集合。
• 约束条件：给定的 k 总是合理的，且 1 ≤ k ≤ 数组中不相同的元素的个数。

算法思路

解决出现频率前 k 高的元素问题的一般思路如下：

• 首先，我们可以使用哈希表统计数组中每个元素的频率。
• 然后，我们可以使用最小堆（优先队列）来找到频率前 k 高的元素。

public class TopKFrequentElements {

    public static int[] topKFrequent(int[] nums, int k) {
        // 使用哈希表统计每个元素的频率
        Map<Integer, Integer> frequencyMap = new HashMap<>();
        for (int num : nums) {
            frequencyMap.put(num, frequencyMap.getOrDefault(num, 0) + 1);
        }

        // 使用最小堆找到频率前 k 高的元素
        PriorityQueue<Map.Entry<Integer, Integer>> minHeap =
                new PriorityQueue<>((a, b) -> a.getValue() - b.getValue());
        for (Map.Entry<Integer, Integer> entry : frequencyMap.entrySet()) {
            minHeap.offer(entry);
            if (minHeap.size() > k) {
                minHeap.poll();
            }
        }

        // 构建结果数组
        int[] result = new int[k];
        for (int i = 0; i < k; i++) {
            result[i] = Objects.requireNonNull(minHeap.poll()).getKey();
        }

        return result;
    }

    public static void main(String[] args) {
        int[] nums1 = {1, 1, 1, 2, 2, 3};
        int k1 = 2;
        System.out.println(Arrays.toString(topKFrequent(nums1, k1))); // Output: [1, 2]

        int[] nums2 = {1};
        int k2 = 1;
        System.out.println(Arrays.toString(topKFrequent(nums2, k2))); // Output: [1]
    }
}