数组算法实战：从二分查找到滑动窗口优化

1. 为什么数组算法是编程基本功

数组作为最基本的数据结构之一，几乎出现在所有编程场景中。从内存管理角度看，数组是连续的内存块，这使得它的随机访问时间复杂度达到O(1)。但正是这种简单的物理结构，衍生出了各种精妙的算法思想。

在实际工程中，我处理过这样一个性能问题：一个电商平台的商品推荐列表，当用户滚动加载时出现明显卡顿。通过性能分析发现，前端对长数组的处理采用了嵌套循环去重，时间复杂度飙升至O(n²)。改用哈希表+双指针的组合方案后，性能立即提升20倍。这个案例让我深刻体会到，数组算法绝不是纸上谈兵。

2. 二分查找：效率的典范

2.1 标准二分实现要点

二分查找的前提是数组有序，其核心思想是每次比较都将搜索范围减半。以下是Java实现模板：

java复制int binarySearch(int[] nums, int target) {
    int left = 0, right = nums.length - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2; // 防止溢出
        if (nums[mid] == target) return mid;
        else if (nums[mid] < target) left = mid + 1;
        else right = mid - 1;
    }
    return -1;
}

关键细节：计算mid时使用left + (right - left)/2而非(left+right)/2，可避免整数溢出。这是实际工程中容易忽略的安全隐患。

2.2 变种问题实战

真实场景往往需要处理边界条件。比如在日志时间戳数组中查找第一个大于等于某时间的索引：

python复制def find_first_larger(nums, target):
    left, right = 0, len(nums)
    while left < right:
        mid = (left + right) // 2
        if nums[mid] < target:
            left = mid + 1
        else:
            right = mid
    return left

这种变种在监控系统告警触发、日程安排等场景十分常见。注意循环条件变为left < right，且right初始值为长度而非长度减一。

3. 双指针法的艺术

3.1 同向指针的妙用

快慢指针是处理有序数组去重的利器。下面这个案例来自某数据库系统的实际优化：

javascript复制function removeDuplicates(nums) {
    if (nums.length === 0) return 0;
    let slow = 0;
    for (let fast = 1; fast < nums.length; fast++) {
        if (nums[fast] !== nums[slow]) {
            slow++;
            nums[slow] = nums[fast];
        }
    }
    return slow + 1;
}

在内存有限的嵌入式设备中，这种原地算法比新建数组方案节省了80%的内存消耗。慢指针slow始终指向最新唯一元素，快指针fast探索新元素。

3.2 相向指针的场景

两数之和问题的最佳解法展示了相向指针的威力。假设需要找到数组中两个数使它们的和为特定值：

cpp复制vector<int> twoSum(vector<int>& nums, int target) {
    sort(nums.begin(), nums.end());
    int left = 0, right = nums.size() - 1;
    while (left < right) {
        int sum = nums[left] + nums[right];
        if (sum == target) return {left, right};
        else if (sum < target) left++;
        else right--;
    }
    return {};
}

这种方案时间复杂度为O(nlogn)，比暴力法的O(n²)有质的提升。在支付系统的金额匹配、游戏装备属性组合等场景都有应用。

4. 滑动窗口：子数组问题的解法

4.1 固定窗口大小问题

考虑监控系统中需要统计每5分钟的错误次数。固定窗口解法：

python复制def fixed_window(nums, k):
    window_sum = sum(nums[:k])
    max_sum = window_sum
    for i in range(k, len(nums)):
        window_sum += nums[i] - nums[i - k]
        max_sum = max(max_sum, window_sum)
    return max_sum

这个算法只需一次遍历，时间复杂度O(n)。在金融领域的移动平均线计算、网络流量分析等场景表现优异。

4.2 可变窗口的复杂场景

最小覆盖子串是可变窗口的经典案例。假设要在字符串中找到包含所有目标字符的最短子串：

java复制public String minWindow(String s, String t) {
    Map<Character, Integer> need = new HashMap<>();
    for (char c : t.toCharArray()) need.put(c, need.getOrDefault(c, 0) + 1);
    
    int left = 0, valid = 0;
    int start = 0, len = Integer.MAX_VALUE;
    Map<Character, Integer> window = new HashMap<>();
    
    for (int right = 0; right < s.length(); right++) {
        char c = s.charAt(right);
        if (need.containsKey(c)) {
            window.put(c, window.getOrDefault(c, 0) + 1);
            if (window.get(c).equals(need.get(c))) valid++;
        }
        
        while (valid == need.size()) {
            if (right - left + 1 < len) {
                start = left;
                len = right - left + 1;
            }
            char d = s.charAt(left++);
            if (need.containsKey(d)) {
                if (window.get(d).equals(need.get(d))) valid--;
                window.put(d, window.get(d) - 1);
            }
        }
    }
    return len == Integer.MAX_VALUE ? "" : s.substring(start, start + len);
}

这个算法在文本搜索、DNA序列匹配等场景有重要应用。关键在于valid计数器与need字典的配合使用。

5. 多维数组处理技巧

5.1 二维数组的螺旋遍历

打印机驱动开发中遇到过这样的需求：将二维矩阵按螺旋顺序输出。解决方案：

javascript复制function spiralOrder(matrix) {
    if (!matrix.length) return [];
    const res = [];
    let top = 0, bottom = matrix.length - 1;
    let left = 0, right = matrix[0].length - 1;
    
    while (true) {
        // 从左到右
        for (let i = left; i <= right; i++) res.push(matrix[top][i]);
        if (++top > bottom) break;
        
        // 从上到下
        for (let i = top; i <= bottom; i++) res.push(matrix[i][right]);
        if (--right < left) break;
        
        // 从右到左
        for (let i = right; i >= left; i--) res.push(matrix[bottom][i]);
        if (--bottom < top) break;
        
        // 从下到上
        for (let i = bottom; i >= top; i--) res.push(matrix[i][left]);
        if (++left > right) break;
    }
    return res;
}

这种边界收缩法在图像处理、矩阵运算等领域很常见。每个方向遍历后立即调整边界值，确保不重复访问。

5.2 岛屿类问题的DFS解法

在游戏开发中，需要计算二维地图中的岛屿数量：

python复制def numIslands(grid):
    if not grid: return 0
    
    count = 0
    for i in range(len(grid)):
        for j in range(len(grid[0])):
            if grid[i][j] == '1':
                dfs(grid, i, j)
                count += 1
    return count

def dfs(grid, i, j):
    if i<0 or j<0 or i>=len(grid) or j>=len(grid[0]) or grid[i][j]!='1':
        return
    grid[i][j] = '0'  # 标记为已访问
    dfs(grid, i+1, j)
    dfs(grid, i-1, j)
    dfs(grid, i, j+1)
    dfs(grid, i, j-1)

这种沉岛法通过DFS将相连的'1'全部标记，每个完整的DFS调用对应一个岛屿。在LBS应用的位置聚类分析中也有类似应用。

6. 算法选择与性能对比

下表总结了不同场景下的算法选择策略：

在实际项目选型时，除了复杂度还要考虑：

1. 数据是否可修改：原地算法优先
2. 数据规模：小数据可用简单实现
3. 访问模式：随机访问多的慎用链表

7. 工程实践中的经验教训

在金融风控系统开发中，我们曾因数组算法选择不当导致线上事故。当时需要实时计算最近1万笔交易的平均金额，最初使用简单队列：

java复制// 错误示范
List<Double> queue = new LinkedList<>();
void addTransaction(double amount) {
    if (queue.size() >= 10000) {
        queue.remove(0);
    }
    queue.add(amount);
}

当QPS达到2000时，这个实现导致GC频繁触发。改进方案：

java复制// 正确方案
double[] circularBuffer = new double[10000];
int count = 0, index = 0;
double sum = 0;

void addTransaction(double amount) {
    if (count >= 10000) {
        sum -= circularBuffer[index];
    } else {
        count++;
    }
    sum += amount;
    circularBuffer[index] = amount;
    index = (index + 1) % 10000;
}

这个案例教会我们：

1. 基础数据结构的操作成本不容忽视
2. 循环数组比链表更节省内存
3. 维护中间结果(sum)可避免重复计算