二分查找与数独验证：算法实战技巧解析

1. 项目概述

最近在整理编程题库时，我集中攻克了第34、35、36三道典型算法题。这三道题看似独立，实则存在内在联系，共同考察了数据结构应用、算法优化和边界条件处理等核心能力。作为过来人，我想分享下解题过程中的思考路径和实战技巧。

这三道题分别涉及：

• 第34题：二分查找变体（在排序数组中查找元素的第一个和最后一个位置）
• 第35题：搜索插入位置（二分查找基础应用）
• 第36题：有效的数独（二维数组与哈希表结合）

提示：虽然题目编号来自LeetCode，但解题思路适用于所有算法题库。建议先独立尝试再参考本文解法。

1.1 核心需求解析

每道题的核心考察点不同：

• 定位问题（34题）：需要修改标准二分查找来处理重复元素的边界定位
• 插入模拟（35题）：考察二分查找的终止条件与返回值处理
• 规则验证（36题）：需要同时检查行、列、子网格三种维度的数据有效性

2. 解题思路与算法选择

2.1 第34题：二分查找的边界处理

标准二分查找找到目标即返回，但本题需要定位重复元素的起始和结束位置。我的解决方案是：

1. 实现findBound辅助函数，通过isLeft参数控制查找方向
2. 当nums[mid] == target时：
   • 找左边界：继续向左搜索（right = mid - 1）
   • 找右边界：继续向右搜索（left = mid + 1）
3. 检查最终位置的有效性

python复制def searchRange(nums, target):
    def findBound(isLeft):
        l, r = 0, len(nums)-1
        bound = -1
        while l <= r:
            mid = (l + r) // 2
            if nums[mid] == target:
                bound = mid
                if isLeft: r = mid - 1
                else: l = mid + 1
            elif nums[mid] < target:
                l = mid + 1
            else:
                r = mid - 1
        return bound
    
    left = findBound(True)
    right = findBound(False)
    return [left, right]

2.2 第35题：二分查找的变体应用

虽然题目看起来更简单，但隐藏两个易错点：

1. 处理目标值不存在时的插入位置
2. 循环终止时左右指针的关系

关键观察：最终left指针总指向第一个大于等于target的位置

python复制def searchInsert(nums, target):
    left, right = 0, len(nums) - 1
    while left <= right:
        mid = (left + right) // 2
        if nums[mid] == target:
            return mid
        elif nums[mid] < target:
            left = mid + 1
        else:
            right = mid - 1
    return left  # 关键点

2.3 第36题：多维数据验证

需要同时检查三个维度：

1. 行内无重复
2. 列内无重复
3. 3x3子网格内无重复

优化技巧：使用集合数组代替字典数组，内存更高效

python复制def isValidSudoku(board):
    rows = [set() for _ in range(9)]
    cols = [set() for _ in range(9)]
    boxes = [set() for _ in range(9)]
    
    for i in range(9):
        for j in range(9):
            num = board[i][j]
            if num == '.':
                continue
                
            box_idx = (i // 3) * 3 + j // 3
            if (num in rows[i]) or (num in cols[j]) or (num in boxes[box_idx]):
                return False
                
            rows[i].add(num)
            cols[j].add(num)
            boxes[box_idx].add(num)
    
    return True

3. 关键实现细节

3.1 二分查找的通用模板

经过这三道题的训练，我总结出二分查找的通用模板：

python复制def binary_search(nums, target):
    left, right = 0, len(nums) - 1
    while left <= right:  # 注意等号
        mid = left + (right - left) // 2  # 防溢出
        if nums[mid] == target:
            # 根据题目需求处理
            return mid
        elif nums[mid] < target:
            left = mid + 1
        else:
            right = mid - 1
    # 返回left或right根据题目而定
    return left

注意：mid计算建议使用left + (right - left) // 2而非(left + right) // 2，避免整数溢出

3.2 数独验证的空间优化

原始解法使用了27个集合，实际上可以用位运算进一步优化：

python复制def isValidSudoku_bit(board):
    rows = [0] * 9
    cols = [0] * 9
    boxes = [0] * 9
    
    for i in range(9):
        for j in range(9):
            if board[i][j] == '.':
                continue
                
            num = int(board[i][j])
            pos = 1 << num
            box_idx = (i // 3) * 3 + j // 3
            
            if (rows[i] & pos) or (cols[j] & pos) or (boxes[box_idx] & pos):
                return False
                
            rows[i] |= pos
            cols[j] |= pos
            boxes[box_idx] |= pos
    
    return True

4. 常见问题与调试技巧

4.1 二分查找典型错误

1. 死循环：通常因为终止条件错误或指针更新不当

   • 检查while条件是<=还是<
   • 确认left和right的更新是否包含±1

2. 边界遗漏：空数组或单元素数组时出错

   • 添加预处理检查：if not nums: return -1

3. 返回值混淆：在34题中容易返回错误的边界

   • 添加后处理验证：if bound == -1 or nums[bound] != target: return -1

4.2 数独验证的调试要点

1. 子网格索引计算错误：

   • 正确公式：box_idx = (i // 3) * 3 + j // 3
   • 常见错误：忘记乘以3或错误使用整除

2. 字符转换遗漏：

   • 必须将字符数字转为整数：num = int(board[i][j])
   • 注意处理'.'的情况

3. 数据结构选择不当：

   • 使用字典会降低性能，推荐用集合或位图

5. 性能对比与优化

通过实际测试对比不同解法的运行时间（单位：微秒）：

优化建议：

1. 二分查找类问题优先考虑O(log n)解法
2. 多维验证问题注意空间复用
3. Python中位运算比集合操作快约20%

6. 扩展练习建议

为了巩固这些技巧，推荐尝试以下变种题：

1. 在旋转排序数组中搜索（二分查找进阶）
2. 寻找峰值元素（二分查找变形）
3. 有效的数独扩展（解数独问题）
4. 在二维矩阵中搜索（行列均有序的情况）

我的实战体会是：算法题的编号可能不同，但核心解题思想是相通的。建议建立自己的解题模板库，遇到新题时先思考能否套用或修改现有模板。比如34题的二分边界查找方法，同样适用于其他需要定位边界的场景。