滑动窗口与双端队列：高效解决数组极值问题

1. 滑动窗口最大值：双端队列的妙用

在处理滑动窗口问题时，双端队列（Deque）是一种极其高效的数据结构。让我们深入分析这个经典问题的解法。

1.1 双端队列的核心思想

双端队列在这里的作用是维护一个递减序列。每次新元素进入时，我们会从队尾开始比较，移除所有小于当前值的元素，确保队列始终保持递减顺序。这种处理方式有以下几个关键点：

1. 队列中存储的是元素索引而非值本身，这便于我们判断元素是否还在窗口范围内
2. 每次窗口滑动时，只需要检查队首元素是否已经超出窗口范围
3. 当前窗口的最大值始终位于队首

注意：在Java中，ArrayDeque的peek/poll操作都是O(1)时间复杂度，这使得整个算法的时间复杂度可以控制在O(n)。

1.2 代码实现细节解析

java复制class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        int[] res = new int[nums.length - k + 1];
        int index = 0;
        Deque<Integer> dp = new ArrayDeque<>();
        
        for (int i = 0; i < nums.length; i++) {
            // 维护递减序列
            while (!dp.isEmpty() && nums[dp.peekLast()] <= nums[i]) {
                dp.pollLast();
            }
            dp.offerLast(i);
            
            // 当窗口形成后开始记录结果
            if (i >= k - 1) {
                // 移除不在窗口内的最大值
                if (dp.peekFirst() <= i - k) {
                    dp.pollFirst();
                }
                res[index++] = nums[dp.peekFirst()];
            }
        }
        return res;
    }
}

1.3 时间复杂度分析

这个算法的时间复杂度是O(n)，其中n是数组长度。虽然有一个内层while循环，但每个元素最多被加入和移除队列各一次，所以总体操作次数是线性的。

2. 最小覆盖子串：滑动窗口的精妙应用

2.1 滑动窗口的基本框架

最小覆盖子串问题要求我们在字符串s中找到包含字符串t所有字符的最短子串。滑动窗口是解决这类子串问题的利器，其基本框架如下：

1. 初始化左右指针l=0, r=0
2. 不断移动右指针r扩大窗口，直到窗口包含所有所需字符
3. 然后移动左指针l缩小窗口，直到窗口不再满足条件
4. 记录满足条件的最小窗口

2.2 实现中的关键点

java复制class Solution {
    public String minWindow(String s, String t) {
        Map<Character, Integer> map = new HashMap<>();
        Set<Character> set = new HashSet<>();
        int tlen = t.length(), slen = s.length();
        
        // 初始化字符频率表
        for (int i = 0; i < tlen; i++) {
            map.put(t.charAt(i), map.getOrDefault(t.charAt(i), 0) + 1);
            set.add(t.charAt(i));
        }
        
        int l = 0, r = 0, start = 0, end = slen, fit = 0;
        while (r < slen) {
            char rc = s.charAt(r);
            if (set.contains(rc)) {
                map.put(rc, map.get(rc) - 1);
                if (map.get(rc) == 0) fit++;
            }
            
            // 当窗口满足条件时尝试收缩左边界
            while (fit == set.size()) {
                // 更新最小窗口
                if (end - start > r - l) {
                    end = r;
                    start = l;
                }
                
                char lc = s.charAt(l);
                if (set.contains(lc)) {
                    map.put(lc, map.get(lc) + 1);
                    if (map.get(lc) == 1) fit--;
                }
                l++;
            }
            r++;
        }
        return end == slen ? "" : s.substring(start, end + 1);
    }
}

2.3 优化技巧

1. 使用fit变量来跟踪当前满足条件的字符数量，避免每次检查整个频率表
2. 使用HashSet存储目标字符，可以快速判断当前字符是否在目标字符串中
3. 在收缩窗口时立即更新最小窗口记录，确保不会错过最优解

3. 最大子数组和：动态规划的经典应用

3.1 Kadane算法解析

最大子数组和问题可以通过Kadane算法高效解决，其核心思想是：

1. 维护一个当前累加和sum
2. 当sum<=0时，它对后续子数组的和没有贡献，可以直接舍弃
3. 每次迭代更新sum和最大值res

java复制class Solution {
    public int maxSubArray(int[] nums) {
        int res = nums[0], sum = nums[0];
        for (int i = 1; i < nums.length; i++) {
            sum = Math.max(nums[i], sum + nums[i]);
            res = Math.max(res, sum);
        }
        return res;
    }
}

3.2 分治解法对比

虽然Kadane算法更高效，但最大子数组和也可以用分治法解决，时间复杂度为O(nlogn)。分治法的基本思路是：

1. 将数组分为左右两部分
2. 递归求解左半部分和右半部分的最大子数组和
3. 计算跨越中点的最大子数组和
4. 返回三者中的最大值

4. 区间合并：排序与合并的艺术

4.1 算法步骤详解

区间合并问题的关键在于先排序后合并：

1. 按照区间起始点进行排序
2. 初始化结果列表，放入第一个区间
3. 遍历后续区间，与结果列表中的最后一个区间比较：
   • 如果重叠则合并
   • 否则直接加入结果列表

java复制class Solution {
    public int[][] merge(int[][] intervals) {
        // 按起始点排序
        Arrays.sort(intervals, (a, b) -> a[0] - b[0]);
        List<int[]> list = new ArrayList<>();
        list.add(intervals[0]);
        
        for (int i = 1; i < intervals.length; i++) {
            int[] last = list.get(list.size() - 1);
            int[] now = intervals[i];
            
            if (last[1] >= now[0]) {
                // 合并区间
                last[1] = Math.max(last[1], now[1]);
            } else {
                list.add(now);
            }
        }
        return list.toArray(new int[list.size()][]);
    }
}

4.2 边界情况处理

1. 空输入：直接返回空数组
2. 单个区间：无需合并直接返回
3. 完全包含的区间：如[1,4]和[2,3]，合并后应为[1,4]

5. 轮转数组：三次反转的巧妙解法

5.1 算法原理

轮转数组可以通过三次反转实现：

1. 反转前n-k个元素
2. 反转后k个元素
3. 反转整个数组

这种方法的时间复杂度是O(n)，空间复杂度是O(1)，是最优解法。

java复制class Solution {
    public void rotate(int[] nums, int k) {
        k = k % nums.length; // 处理k大于数组长度的情况
        reverse(nums, 0, nums.length - 1 - k);
        reverse(nums, nums.length - k, nums.length - 1);
        reverse(nums, 0, nums.length - 1);
    }
    
    private void reverse(int[] nums, int l, int r) {
        while (r > l) {
            int temp = nums[l];
            nums[l] = nums[r];
            nums[r] = temp;
            l++;
            r--;
        }
    }
}

5.2 其他解法对比

1. 使用额外数组：简单但需要O(n)空间
2. 循环替换：时间复杂度O(n)但实现稍复杂
3. 三次反转：最优解，代码简洁高效

6. 除自身以外数组的乘积：前缀积与后缀积

6.1 空间优化技巧

题目要求不能用除法且希望空间复杂度为O(1)(输出数组不算)，可以通过以下方式实现：

1. 先用输出数组存储从左到右的前缀积
2. 然后从右到左遍历，用一个变量维护后缀积，同时更新结果

java复制class Solution {
    public int[] productExceptSelf(int[] nums) {
        int[] res = new int[nums.length];
        res[0] = 1;
        
        // 计算前缀积
        for (int i = 1; i < nums.length; i++) {
            res[i] = res[i - 1] * nums[i - 1];
        }
        
        // 计算后缀积并合并结果
        int suffix = 1;
        for (int i = nums.length - 1; i >= 0; i--) {
            res[i] *= suffix;
            suffix *= nums[i];
        }
        
        return res;
    }
}

6.2 复杂度分析

• 时间复杂度：O(n)，两次遍历
• 空间复杂度：O(1)(不考虑输出数组)

7. 缺失的第一个正数：原地哈希技巧

7.1 算法思想

要在O(n)时间且常数空间内找到缺失的最小正整数，可以使用原地哈希：

1. 遍历数组，将每个正整数x放到x-1的位置上
2. 再次遍历数组，第一个不满足nums[i]==i+1的位置就是缺失的正数

java复制class Solution {
    public int firstMissingPositive(int[] nums) {
        for (int i = 0; i < nums.length; i++) {
            while (nums[i] >= 1 && nums[i] <= nums.length 
                   && nums[i] != nums[nums[i] - 1]) {
                swap(nums, i, nums[i] - 1);
            }
        }
        
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] != i + 1) {
                return i + 1;
            }
        }
        return nums.length + 1;
    }
    
    private void swap(int[] nums, int i, int j) {
        int temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }
}

7.2 关键点说明

1. while循环确保每个数字被放到正确位置
2. 交换时要防止无限循环，所以需要nums[i] != nums[nums[i]-1]条件
3. 第二次遍历时，第一个不满足条件的位置就是答案

8. 矩阵置零：空间复杂度优化

8.1 标记变量法

为了不使用额外空间，可以利用矩阵的第一行和第一列作为标记：

1. 先检查第一行和第一列是否需要置零
2. 用第一行和第一列记录其他行列是否需要置零
3. 根据标记置零其他元素
4. 最后处理第一行和第一列

java复制class Solution {
    public void setZeroes(int[][] matrix) {
        boolean firstRowZero = false;
        boolean firstColZero = false;
        
        // 检查第一行和第一列
        for (int i = 0; i < matrix[0].length; i++) {
            if (matrix[0][i] == 0) {
                firstRowZero = true;
                break;
            }
        }
        
        for (int i = 0; i < matrix.length; i++) {
            if (matrix[i][0] == 0) {
                firstColZero = true;
                break;
            }
        }
        
        // 使用第一行和第一列作为标记
        for (int i = 1; i < matrix.length; i++) {
            for (int j = 1; j < matrix[0].length; j++) {
                if (matrix[i][j] == 0) {
                    matrix[i][0] = 0;
                    matrix[0][j] = 0;
                }
            }
        }
        
        // 根据标记置零
        for (int i = 1; i < matrix.length; i++) {
            for (int j = 1; j < matrix[0].length; j++) {
                if (matrix[i][0] == 0 || matrix[0][j] == 0) {
                    matrix[i][j] = 0;
                }
            }
        }
        
        // 处理第一行和第一列
        if (firstRowZero) {
            for (int j = 0; j < matrix[0].length; j++) {
                matrix[0][j] = 0;
            }
        }
        
        if (firstColZero) {
            for (int i = 0; i < matrix.length; i++) {
                matrix[i][0] = 0;
            }
        }
    }
}

9. 螺旋矩阵：边界控制法

9.1 分层处理思想

螺旋矩阵可以通过控制四个边界来逐层遍历：

1. 从左到右遍历上边界
2. 从上到下遍历右边界
3. 如果下边界不等于上边界，从右到左遍历下边界
4. 如果左边界不等于右边界，从下到上遍历左边界
5. 收缩边界，进入下一层

java复制class Solution {
    public List<Integer> spiralOrder(int[][] matrix) {
        List<Integer> res = new ArrayList<>();
        int m = matrix.length, n = matrix[0].length;
        int up = 0, down = m - 1, left = 0, right = n - 1;
        
        while (up <= down && left <= right) {
            // 从左到右
            for (int i = left; i <= right; i++) {
                res.add(matrix[up][i]);
            }
            up++;
            
            // 从上到下
            for (int i = up; i <= down; i++) {
                res.add(matrix[i][right]);
            }
            right--;
            
            if (up > down) break;
            // 从右到左
            for (int i = right; i >= left; i--) {
                res.add(matrix[down][i]);
            }
            down--;
            
            if (left > right) break;
            // 从下到上
            for (int i = down; i >= up; i--) {
                res.add(matrix[i][left]);
            }
            left++;
        }
        return res;
    }
}

10. 旋转图像：翻转代替旋转

10.1 数学规律应用

旋转图像90度可以通过两次翻转实现：

1. 先沿水平中线上下翻转
2. 再沿主对角线翻转

java复制class Solution {
    public void rotate(int[][] matrix) {
        int n = matrix.length;
        
        // 上下翻转
        for (int i = 0; i < n / 2; i++) {
            for (int j = 0; j < n; j++) {
                int temp = matrix[i][j];
                matrix[i][j] = matrix[n - 1 - i][j];
                matrix[n - 1 - i][j] = temp;
            }
        }
        
        // 对角线翻转
        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {
                int temp = matrix[i][j];
                matrix[i][j] = matrix[j][i];
                matrix[j][i] = temp;
            }
        }
    }
}

10.2 其他旋转角度

1. 旋转180度：可以两次90度旋转，或者直接中心对称交换
2. 旋转270度：可以三次90度旋转，或者先对角线翻转再上下翻转