算法：分别用循环和递归实现二分法

思路

二分法的思路不用多说，就是每次查找一半。

通过定义 startIndex、endIndex代表查找的范围，用一个 while 循环不断的缩小这两个 index 直接的差距，如果两个 index 相遇则结束，说明没找到，

二分查找（循环）

/**
 * 二分查找（循环）
 * @param arr arr
 * @param target target
 */
export function binarySearch1(arr: number[], target: number): number {
    
    
    const length = arr.length
    if (length === 0) return -1

    let startIndex = 0 // 开始位置
    let endIndex = length - 1 // 结束位置

    while (startIndex <= endIndex) {
    
    
        const midIndex = Math.floor((startIndex + endIndex) / 2)
        const midValue = arr[midIndex]
        if (target < midValue) {
    
    
            // 目标值较小，则继续在左侧查找
            endIndex = midIndex - 1
        } else if (target > midValue) {
    
    
            // 目标值较大，则继续在右侧查找
            startIndex = midIndex + 1
        } else {
    
    
            // 相等，返回
            return midIndex
        }
    }

    return -1
}

二分查找（递归）

/**
 * 二分查找（递归）
 * @param arr arr
 * @param target target
 * @param startIndex start index
 * @param endIndex end index
 */
export function binarySearch2(arr: number[], target: number, startIndex?: number, endIndex?: number): number {
    
    
    const length = arr.length
    if (length === 0) return -1

    // 开始和结束的范围
    if (startIndex == null) startIndex = 0
    if (endIndex == null) endIndex = length - 1

    // 如果 start 和 end 相遇，则结束
    if (startIndex > endIndex) return -1

    // 中间位置
    const midIndex = Math.floor((startIndex + endIndex) / 2)
    const midValue = arr[midIndex]

    if (target < midValue) {
    
    
        // 目标值较小，则继续在左侧查找
        return binarySearch2(arr, target, startIndex, midIndex - 1)
    } else if (target > midValue) {
    
    
        // 目标值较大，则继续在右侧查找
        return binarySearch2(arr, target, midIndex + 1, endIndex)
    } else {
    
    
        // 相等，返回
        return midIndex
    }
}

测试

// // 功能测试
const arr = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120]
const target = 40
console.info(binarySearch2(arr, target))

// 性能测试
console.time('binarySearch1')
for (let i = 0; i < 100 * 10000; i++) {
    
    
    binarySearch1(arr, target)
}
console.timeEnd('binarySearch1') // 17ms
console.time('binarySearch2')
for (let i = 0; i < 100 * 10000; i++) {
    
    
    binarySearch2(arr, target)
}
console.timeEnd('binarySearch2') // 34ms

测试用例

import {
    
     binarySearch1, binarySearch2 } from './binary-search'

describe('二分查找', () => {
    
    
    it('正常情况', () => {
    
    
        const arr = [10, 20, 30, 40, 50]
        const target = 40
        const index = binarySearch1(arr, target)
        expect(index).toBe(3)
    })

    it('空数组', () => {
    
    
        expect(binarySearch1([], 100)).toBe(-1)
    })

    it('找不到 target', () => {
    
    
        const arr = [10, 20, 30, 40, 50]
        const target = 400
        const index = binarySearch1(arr, target)
        expect(index).toBe(-1)
    })
})

在数量级上都是 O(logn)，非常快。扣细节的话，递归会慢一点。因为：
循环调用一次函数，递归则会调用很多次函数，函数的调用是有开销的。

总结

• 递归代码更简洁清晰。
• 非递归性能更好，但是不会相差很大。

凡有序，必二分