[typescript]二分查找算法进阶总结（包括旋转数组）

关于二分查找的题型

普通的二分

• LC704 二分查找 简单
• LC34 在排序数组中查找元素的第一个和最后一个位置 中等

变体：旋转数组

• LC153 寻找旋转排序数组的最小值 中等
• LC33 搜索旋转排序数组 中等

二分通用技巧

最常用最基础的二分查找，接收一个数组，和一个target目标值，要寻找到这个目标，返回该目标的下标。找不到就返回-1。直接对应LC704的答案

function search(nums: number[], target: number): number {
    let left: number = 0, right: number = nums.length - 1
    while (left <= right) {
        let mid: number = Math.floor(left + (right - left) / 2)
        if (nums[mid] < target){
            left = mid + 1
        } else if (nums[mid] > target){
            right = mid - 1
        } else if (nums[mid] === target){
            return mid
        }
    }
    return -1
};

注意点：

1. 不用 mid = Math.floor((left + right)/2) 的主要原因是怕超出最大值
2. while里的left<=right而不是单纯的小于，是因为我们需要搜索的区域是一个闭区间，也就是[left,right]，这样才能确定不漏掉一个数

但是，有些时候，目标值不止一个，也就是说可能有多个目标值，我们需要找到其左边界和右边界，所以上面的算法靠不住了，但是依然可以在上面的算法中做一定的改动。这里主要学习到的是labuladong的算法秘籍中提到的思路。

假设在一个新的数组中，[1,2,3,3,3,4]，我们要找target = 3的左右边界，怎么办呢？

这里直接贴LC34里我的解法，超过了98%的同学

//main function
function searchRange(nums: number[], target: number): number[] {
    return [leftBound(nums,target), rightBound(nums,target)]
};

//find left bound
function leftBound(nums: number[], target: number): number {
    let left: number = 0, right: number = nums.length - 1
    while (left <= right){
        let mid: number = Math.floor(left + (right - left)/2)
        if (nums[mid] < target){
            left = mid + 1
        } else if (nums[mid] > target){
            right = mid - 1
        } else {
            right = mid - 1
        }
    }
    //重点部分
    if (left >= nums.length || nums[left] !== target) {
        return -1
    } else {
        return left
    }
}


//find right bound
function rightBound(nums: number[], target: number): number {
    let left: number = 0, right: number = nums.length - 1
    while (left <= right){
        let mid: number = Math.floor(left + (right - left)/2)
        if (nums[mid] < target){
            left = mid + 1
        } else if (nums[mid] > target){
            right = mid - 1
        } else {
            left = mid + 1
        }
    }
    //重点部分
    if (right < 0 || nums[right] !== target) {
        return -1
    } else {
        return right
    }
}

这个题目的意思很简单，就是让我们找到左右边界而已，那我们分别去找左边界和右边界就行。仔细观察的话，会发现和基础的差别不大，但是多出来两行判断结果的部分。然后在nums[mid] === target 的时候，我们没有去输出，而是缩小边界继续查找。

重点的部分，在于理解，什么时候会跳出循环，我们给定的条件是left <= right， 因此，当left > right 的时候，就可以跳出循环。

先考虑leftBound这个函数，当nums[mid]正好等于左边界的时候，我们的right再次缩小范围到左边界-1的位置，此之后的left会不停的增大直到和right相等，最后left = mid + 1 便刚刚好大于right，且等于左边界的位置。

跳出循环之后，再次进行判断，因为我们没有考虑两种极端情况，一种是left超过边界，一种是找到的左边界并不等于target，这样算出来的结果就是正确的。

旋转数组：二分查找的变体

在leetcode中，有不少旋转数组的题，这里挑两个聊聊。一个是LC153的最基础的旋转数组。像是[3,4,5,0,1,2]就是典型的旋转数组，我们可以发现规律，就是除了中间一个点是无序的，其余的都是有序的，那我们是不是通过二分查找可以去找到这个旋转点呢？（有的同学选择直接遍历，也不是不行，就是在数据量巨大的时候，时间复杂度很高）在这个题目中，我们只要输出0就可以，也就是所说的旋转点。直接贴答案

function findMin(nums: number[]): number {
    let left: number = 0, right: number = nums.length - 1
    while (left < right){
        let mid: number = Math.floor(left + (right - left) /2)
        if (nums[mid] < nums[right]){
            right = mid
        } else if (nums[mid] > nums[right]){
            left = mid + 1
        }
    }
    return nums[left]
};

这里又出现了一个比较坑的点，为什么是left < right呢，一个等号区别这么大吗？ 我试过改为小于等于，再改点其他地方七七八八，发现都得不到正确的结果。咱来仔细分析一下原因。

之前说过一个问题，那就是判断循环的出口条件，这里的话就是left === right，循环就结束了，我们想找到的旋转点是最小值，所以当我们在mid刚好是旋转点时，肯定是进入的第一个判断。

为什么呢？为什么我能确定mid一定比此时的right小呢，第一个原因是Math.floor，mid跟right相等的唯一条件是left === right，就退出循环了。所以我们下一步得到的是mid = 旋转点 - 1，此时对应的数值是最大值，所以肯定比刚才的right大，然后left和right相等，退出循环，返回left和right皆可。

所以说二分查找，如果要讨论的非常细致的话，边界条件是考虑的非常复杂的。

最后看一个题，是LC33，搜索旋转排序数组，其实就是把旋转数组和二分查找的经典模版结合而已。

function search(nums: number[], target: number): number {
    const spin = findSpinIndex(nums)
    if (target < nums[spin] || target > nums[spin - 1]) {
        return -1
    } else if (target > nums[nums.length - 1]){
        return binarySearch(nums, target, 0, spin - 1)
    } else if (target <= nums[nums.length - 1]){
        return binarySearch(nums, target, spin, nums.length - 1)
    }
};

function findSpinIndex(nums:number[]): number {
    let left: number = 0, right: number = nums.length - 1
    while (left < right){
        let mid: number = Math.floor(left + (right - left) / 2)
        if (nums[mid] < nums[right]){
            right = mid
        } else if (nums[mid] > nums[right]){
            left = mid + 1
        }
    }
    return left
}

function binarySearch(nums: number[], target: number, leftBound: number, rightBound: number): number {
    let left: number = leftBound, right: number = rightBound
    while (left <= right){
        let mid: number = Math.floor(left + (right - left) / 2)
        if (nums[mid] > target){
            right = mid - 1
        } else if (nums[mid] < target){
            left = mid + 1
        } else if (nums[mid] === target) {
            return mid
        }
    } 
    return -1 
}

这个题没什么特别需要注意的地方，注意一下主函数的边界判断就好