数组算法精讲：二分查找与双指针实战

1. 算法训练营Day1：数组专题精讲

作为一名算法工程师，我深知数组是最基础也是最重要的数据结构之一。今天我将分享卡码算法训练营第一天关于数组的三大经典问题：二分查找、移除元素和有序数组的平方。这些题目看似简单，但蕴含着许多值得深入探讨的细节和技巧。

2. 二分查找：不只是简单的折半查找

2.1 二分查找的核心思想

二分查找(Binary Search)是一种在有序数组中查找特定元素的算法。它的核心思想是通过不断缩小搜索范围来快速定位目标元素。每次比较都将搜索范围缩小一半，因此时间复杂度为O(log n)，效率远高于线性查找的O(n)。

提示：二分查找的前提是数组必须是有序的，否则算法将无法正常工作。

2.2 代码实现详解

让我们仔细分析LeetCode 704题的实现代码：

cpp复制class Solution {
public:
    int search(vector<int>& nums, int target) {
        int left = 0;
        int right = nums.size() - 1;
        while (left <= right) {
            int middle = left + ((right - left) / 2);
            if (nums[middle] > target) {
                right = middle - 1;
            } else if (nums[middle] == target) {
                return middle;
            } else if (nums[middle] < target) {
                left = middle + 1;
            }
        }
        return -1;
    }
};

这段代码有几个关键点需要注意：

1. 边界条件：使用left <= right而不是left < right，确保能处理边界情况
2. 中间值计算：使用left + ((right - left) / 2)而不是(left + right)/2，防止整数溢出
3. 边界更新：right = middle - 1和left = middle + 1而不是right = middle和left = middle，避免死循环

2.3 常见错误与调试技巧

在实际编码中，二分查找容易出现以下几种错误：

1. 死循环：通常是由于边界更新不当导致的
2. 漏查元素：边界条件设置不正确可能导致某些元素被跳过
3. 溢出问题：中间值计算时可能出现整数溢出

调试技巧：

• 打印每次循环的left、right和middle值
• 使用小数组测试边界情况
• 验证数组是否确实有序

3. 移除元素：双指针法的经典应用

3.1 问题理解与解法分析

LeetCode 27题要求我们原地移除数组中所有等于给定值的元素，并返回新数组的长度。这里的"原地"意味着不能使用额外的数组空间，必须在原数组上操作。

双指针法是解决这类问题的利器。我们使用两个指针：

• 快指针(fast)：遍历整个数组
• 慢指针(slow)：记录新数组的位置

3.2 代码实现与解析

cpp复制class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int slow = 0;
        for (int fast = 0; fast < nums.size(); fast++) {
            if (val != nums[fast]) {
                nums[slow] = nums[fast];
                slow++;
            }
        }
        return slow;
    }
};

这个实现的关键点：

1. 时间复杂度：O(n)，只需遍历数组一次
2. 空间复杂度：O(1)，没有使用额外空间
3. 稳定性：保持了非val元素的相对顺序

3.3 变种与扩展

这个问题有几个有趣的变种：

1. 如果不需要保持元素顺序，可以使用首尾双指针法，效率更高
2. 如果要统计val出现的次数，可以稍作修改
3. 如果要同时移除多个不同的值，逻辑需要相应调整

4. 有序数组的平方：双指针的巧妙运用

4.1 问题分析

LeetCode 977题给定一个非递减顺序排序的整数数组，要求返回每个数字平方后仍按非递减顺序排序的新数组。

最直观的解法是先平方再排序，时间复杂度为O(nlogn)。但利用数组已排序的特性，我们可以用双指针法实现O(n)的时间复杂度。

4.2 双指针解法详解

cpp复制class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        int n = nums.size();
        vector<int> res(n);
        int left = 0, right = n - 1;
        int index = n - 1;
        while (left <= right) {
            int leftSq = nums[left] * nums[left];
            int rightSq = nums[right] * nums[right];
            if (leftSq > rightSq) {
                res[index--] = leftSq;
                left++;
            } else {
                res[index--] = rightSq;
                right--;
            }
        }
        return res;
    }
};

这个解法的精妙之处在于：

1. 利用原数组已排序的特性
2. 最大的平方值只可能出现在数组的两端
3. 从后向前填充结果数组，确保顺序正确

4.3 性能对比

在实际应用中，当n较大时，双指针法的优势非常明显。

5. 数组问题的通用解题思路

通过这三个题目，我们可以总结出处理数组问题的一些通用方法：

1. 双指针法：适用于需要原地修改数组或同时比较多个元素的情况
2. 二分查找：适用于有序数组的查找问题
3. 滑动窗口：适用于子数组或子序列问题
4. 前缀和：适用于频繁查询区间和的情况

在实际面试中，理解这些模式并能灵活运用非常重要。我建议初学者可以按照以下步骤练习：

1. 理解题目要求
2. 分析输入输出特性
3. 选择合适的数据结构和算法
4. 编写代码并测试边界条件
5. 优化时间和空间复杂度

6. 常见问题与解决方案

在教授算法和指导学员的过程中，我发现以下几个问题是初学者经常遇到的：

1. 边界条件处理不当

   • 解决方案：仔细考虑循环终止条件和指针移动规则
   • 示例：二分查找中的left <= right vs left < right

2. 时间复杂度分析错误

   • 解决方案：画出算法执行流程图，计算基本操作次数
   • 示例：双指针法通常为O(n)，而非直觉认为的O(n^2)

3. 空间复杂度优化不足

   • 解决方案：优先考虑原地操作，必要时才使用额外空间
   • 示例：移除元素问题中的原地修改

4. 代码冗余

   • 解决方案：提取重复逻辑为函数或变量
   • 示例：平方计算可以提前存储避免重复计算

7. 实战经验分享

经过多年的算法教学和实战，我总结出以下几点经验：

1. 从暴力解法开始：先写出最直观的解法，再考虑优化
2. 画图辅助理解：特别是双指针和滑动窗口问题
3. 测试用例要全面：包括空数组、单元素数组、全相同元素等边界情况
4. 注重代码可读性：良好的变量命名和适当注释很重要
5. 理解而非记忆：掌握算法思想比死记硬背代码更重要

对于数组问题，我特别推荐使用"纸上编码"法：先在纸上写出算法步骤和伪代码，确认逻辑正确后再开始实际编码。这种方法能显著减少调试时间。

在实际工程中，数组操作往往伴随着更多业务约束。例如，可能需要处理超大数组（内存不足）、并发访问（线程安全）或特殊数据类型（自定义对象）。这些情况下，基础算法的变通应用就显得尤为重要。