二分查找（算法）

如题，二分查找只是针对有序数组中查找特定元素的搜索一种算法！二分查找很好写，却很难写对，下面我来一一介绍下二分查找和二分查找的变种！

1.原理

在一个有序的数组中，平分数组，取到中间值（x），这时数组已经被这个x分割成两部分left和right，[left,x,right],用值(n)和这个中间（x）做对比！(如果比x大，那目标就缩小到right这部分，然后继续平分right数组，取到中间值（x1），这时数组已经被这个x分割成两部分left1和right1，[left1,x1,right1]，接着比较这个值(n)和这个中间（x1）做对比，一直反复，直到n=x1,找出索引)，反之一样！

2.最基本的二分查找

while循环代码

function binarySearch(arr, number) {
    let  left = 0;//左边索引
    let  right = arr.length - 1;//右边索引
    while (left <= right) {
        let  middle = parseInt((left + right) / 2);//取中间值
        if (arr[middle] == number) {
            return middle;
        } else if (number < arr[middle]) {//值比中间值小，取中间值索引-1为右边索引
            right = middle - 1;
        } else if (number > arr[middle]) {//值比中间值大，取中间值索引+1为左边索引
            left = middle + 1;
        };
    };
    return -1;//找不到
};
console.log(binarySearch([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 6)); //5

循环的判定条件是：left <= right

递归实现

function binarySearch(arr, number) {
    let left = 0;
    let right = arr.length - 1;
    //返回个闭包函数
    return (function recursiveFn(arr, number, left, right) {
        let middle = parseInt((left + right)/ 2);//取中间值
        if (left <= right) {
            if (arr[middle] == number) {
                return middle;
            } else if (number < arr[middle]) {//值比中间值小，取中间值索引-1为右边索引
                right = middle - 1;
                return recursiveFn(arr, number, left, right);//递归
            } else if (number > arr[middle] ) {//值比中间值大，取中间值索引+1为左边索引
                left = middle + 1;
                return recursiveFn(arr, number, left, right);//递归
            }
        }
        return -1;//找不到
    })(arr, number, left, right);
};
console.log(binarySearch([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 6));

递归判定条件是：对比的值和中间值相等，跳出递归！

3.二分查找的变种（你要找的值为number）

1.假如数组里面有很多相同number，你要找第一个和number相等的值的索引,找不到返-1

 function binarySearch(arr, number) {
     let left = 0;
     let right = arr.length - 1;
     while (left <= right) {
         let middle = parseInt((left + right) / 2);
         if (number <= arr[middle]) {
             right = middle - 1;
         } else if (number > arr[middle]) {
             left = middle + 1;
         };
     };
     if (left < arr.length && arr[left] == number) {
         return left;
     };
     return -1;
 };
console.log(binarySearch([1, 2, 3, 4, 5, 6, 6, 6, 6, 7, 8, 9, 10], 6)); //5

这里就需要注意的是当找到number <= arr[middle]相等时，还需要减少right的值，直到 left > right 跳出循环 ！


2.假如数组里面有很多相同number，你要找最后一个和number相等的值的索引，找不到返-1

function binarySearch(arr, number) {
     let left = 0;
     let right = arr.length - 1;
     while (left <= right) {
         let middle = parseInt((left + right) / 2);
         if (number < arr[middle]) {
             right = middle - 1;
         } else if (number >= arr[middle]) {
             left = middle + 1;
         };
     };
     if (right > 0 && arr[right] == number) {
         return right;
     };
     return -1;
 };
 console.log(binarySearch([1, 2, 3, 4, 5, 6, 6, 6, 6, 7, 8, 9, 10], 6)); //8

当找到number >= arr[middle]相等时，需要增加left的值，直到 left > right 跳出循环 ！

3.要找第一个大于等于number的索引

function binarySearch(arr, number) {
    let left = 0;
    let right = arr.length - 1;
    while (left <= right) {
        let middle = parseInt((left + right) / 2);
        if (number <= arr[middle]) {
            right = middle - 1;
        } else if (number > arr[middle]) {
            left = middle + 1;
        };
    };
    return left;
};
console.log(binarySearch([1, 1, 2, 3, 4, 5, 6, 6, 6, 6, 8, 9, 10], 6)); //6

要找第一个，肯定是返回left，那么number <= arr[middle]只能是每次right-1，直到left>right 才跳出循环！

3.要找最后一个大于等于number的索引

function binarySearch(arr, number) {
    let left = 0;
    let right = arr.length - 1;
    while (left <= right) {
        let middle = parseInt((left + right) / 2);
        if (number < arr[middle]) {
            right = middle - 1;
        } else if (number >= arr[middle]) {
            left = middle + 1;
        };
    };
    return right;
};
console.log(binarySearch([1, 1, 2, 3, 4, 5, 6, 6, 6, 6, 8, 9, 10], 6)); //9

要找第一个，肯定是返回right，那么number >= arr[middle]只能是每次left+1，直到left>right 才跳出循环！

4.时间复杂度分析

每次查询可以排除一半的数组（数组长度减半），如果数组长度为n,那么时间复杂度为log2ⁿ ,用大O表示法为O(log n)！

5.总结：

其实还有很多变种，只要懂了二分查找的套路，再多的变种也可以迎刃而解！二分查找最主要的就是要理清楚left 和right这两个值！当left>right 或者这么说 left=right-1时，循环终止了！ 那么left,right 肯定是两边的边界值！关于number 和 arr[middle] 什么时候应该加等号，这个很多人理不清楚！如果arr 里面有多个和 number相等的值，这里有两种情况： 1. 你想取第一个相等的就要return left ,并且当left=right-1时，循环终止，所以必须number <= arr[middle]； 2. 你想取最后个相等的就要return right,并且当left=right-1时，循环终止，所以必须number >= arr[middle]；