当前位置：首页 > news >正文

TypeScript实现二分查找算法：原理剖析与最佳实践

news 来源：原创 2025/5/17 13:03:44

一、为什么需要二分查找？

在编程世界中，搜索是最基础也是最重要的操作之一。当我们面对一个包含10万个元素的有序数组时，线性搜索需要平均5万次比较操作，而二分查找仅需约17次比较即可完成搜索！这种指数级效率提升（时间复杂度O(log n)）使其成为处理大型有序数据集的必备算法。

二、算法核心原理

2.1 基本工作流程

确定搜索区间：初始为整个数组
计算中间索引：mid = left + Math.floor((right - left) / 2)
比较中间元素：
- 等于目标值 → 返回索引
- 小于目标值 → 收缩左边界
- 大于目标值 → 收缩右边界
重复步骤2-3 直到找到元素或区间无效

2.2 算法可视化演示

初始数组: [2, 5, 8, 12, 16, 23, 38, 45]
查找目标: 23

第1次循环：mid=3(12) < 23 → left=4
第2次循环：mid=5(23) == 23 → 找到目标

三、TypeScript实现详解

3.1 基础实现（循环版本）

function binarySearch<T>(arr: T[], target: T): number {
    let left = 0;
    let right = arr.length - 1;

    while (left <= right) {
        const mid = left + Math.floor((right - left) / 2);
        const current = arr[mid];

        if (current === target) {
            return mid;
        } else if (current < target) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }

    return -1;
}

// 使用示例
const sortedNumbers = [2, 5, 8, 12, 16, 23, 38, 45];
console.log(binarySearch(sortedNumbers, 23)); // 输出: 5

3.2 递归版本实现

function recursiveBinarySearch<T>(
    arr: T[], 
    target: T,
    left: number = 0,
    right: number = arr.length - 1
): number {
    if (left > right) return -1;

    const mid = left + Math.floor((right - left) / 2);
    const current = arr[mid];

    if (current === target) return mid;
    if (current < target) {
        return recursiveBinarySearch(arr, target, mid + 1, right);
    }
    return recursiveBinarySearch(arr, target, left, mid - 1);
}

3.3 支持自定义比较函数

interface CompareFunction<T> {
    (a: T, b: T): number;
}

function advancedBinarySearch<T>(
    arr: T[],
    target: T,
    compare: CompareFunction<T> = (a, b) => (a < b ? -1 : a > b ? 1 : 0)
): number {
    let left = 0;
    let right = arr.length - 1;

    while (left <= right) {
        const mid = left + Math.floor((right - left) / 2);
        const comparison = compare(arr[mid], target);

        if (comparison === 0) return mid;
        if (comparison < 0) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }

    return -1;
}

// 对象数组搜索示例
interface User {
    id: number;
    name: string;
}

const users: User[] = [
    {id: 100, name: 'Alice'},
    {id: 202, name: 'Bob'},
    {id: 305, name: 'Charlie'}
];

const targetUser = advancedBinarySearch(users, {id: 202}, (a, b) => a.id - b.id);
console.log(targetUser); // 输出: 1

四、关键实现细节解析

4.1 防止整数溢出

// 传统写法可能溢出
const mid = Math.floor((left + right) / 2);

// 安全写法
const mid = left + Math.floor((right - left) / 2);

4.2 边界条件处理

边界情况	处理方式
空数组	直接返回-1
单个元素数组	直接比较
重复元素	返回任意匹配索引（标准实现）
目标不存在	返回-1

4.3 时间复杂度分析

最佳情况：O(1)（第一次就找到）
平均情况：O(log n)
最坏情况：O(log n)

空间复杂度：

循环版本：O(1)
递归版本：O(log n)（调用栈深度）

五、实际应用场景

5.1 经典使用案例

数据库索引查询
游戏高分排行榜
自动补全建议系统
版本控制系统中的变更查找
地理空间数据查询（如经纬度范围）

5.2 变种算法应用

// 查找第一个出现的位置
function findFirstOccurrence<T>(arr: T[], target: T): number {
    let left = 0;
    let right = arr.length - 1;
    let result = -1;

    while (left <= right) {
        const mid = left + Math.floor((right - left) / 2);
        if (arr[mid] === target) {
            result = mid;
            right = mid - 1; // 继续向左查找
        } else if (arr[mid] < target) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    return result;
}

// 查找插入位置（bisect_left）
function findInsertPosition<T>(arr: T[], target: T): number {
    let left = 0;
    let right = arr.length;

    while (left < right) {
        const mid = left + Math.floor((right - left) / 2);
        if (arr[mid] < target) {
            left = mid + 1;
        } else {
            right = mid;
        }
    }
    return left;
}

六、性能优化技巧

内存局部性优化：使用紧凑数据结构
分支预测优化：减少条件判断次数
循环展开：处理最后几个元素
SIMD指令：并行比较（需要底层支持）
缓存预处理：存储中间计算结果

// 优化后的比较版本
function optimizedBinarySearch(arr: number[], target: number): number {
    let left = 0;
    let right = arr.length - 1;

    while (right - left > 3) {
        const mid = left + ((right - left) >> 1);
        if (arr[mid] >= target) {
            right = mid;
        } else {
            left = mid + 1;
        }
    }

    // 处理剩余元素
    for (let i = left; i <= right; i++) {
        if (arr[i] === target) return i;
    }
    return -1;
}

七、测试用例设计

// Jest测试示例
describe('binarySearch', () => {
    const testArray = [2, 5, 8, 12, 16, 23, 38, 45];

    test('查找存在的元素', () => {
        expect(binarySearch(testArray, 23)).toBe(5);
    });

    test('查找不存在的元素', () => {
        expect(binarySearch(testArray, 20)).toBe(-1);
    });

    test('空数组测试', () => {
        expect(binarySearch([], 1)).toBe(-1);
    });

    test('单个元素数组', () => {
        expect(binarySearch([7], 7)).toBe(0);
    });

    test('重复元素处理', () => {
        const duplicates = [2, 5, 5, 5, 16];
        const index = binarySearch(duplicates, 5);
        expect(index >= 1 && index <= 3).toBeTruthy();
    });
});

八、注意事项与限制

前置条件：必须是有序数组
数据规模：小数组（n<100）可能线性搜索更快
内存限制：不适合链表等非随机访问数据结构
浮点数精度：比较时需要注意精度问题
稳定性：标准实现不保证相同元素的顺序

九、延伸思考

三分查找：适用于单峰函数极值查找
指数搜索：适合无限/未知长度数组
插值搜索：适用于均匀分布数据
分布式二分查找：大数据集的并行处理

// 指数搜索实现
function exponentialSearch<T>(arr: T[], target: T): number {
    if (arr[0] === target) return 0;

    let bound = 1;
    while (bound < arr.length && arr[bound] <= target) {
        bound *= 2;
    }

    return binarySearch(
        arr,
        target,
        Math.floor(bound / 2),
        Math.min(bound, arr.length - 1)
    );
}