究竟是什么样的讲解二分查找算法的博客让我写了三小时？？？

版本说明

当前版本号[20230926]。

版本	修改说明
20230926	初版

目录

二分查找

二分查找算法也称折半查找，是一种非常高效的工作于有序数组的查找算法。后续的课程中还会学习更多的查找算法，但在此之前，不妨用它作为入门。

基础版

需求：在有序数组 $A$ 内，查找值 $target$

• 如果找到返回索引
• 如果找不到返回 $-1$

算法描述

前提	给定一个内含 $n$ 个元素的有序数组 $A$，满足 $A_0\le A_1\le A_2\le \cdots \le A_{n-1}$，一个待查值 $target$
1	设置 $i=0$，$j=n-1$
2	如果 $i>j$，结束查找，没找到
3	设置 $m=floor(\frac{i+j}{2})$ ，$m$ 为中间索引，$floor$ 是向下取整（$\le \frac{i+j}{2}$ 的最小整数）
4	如果 $target<A_m$ 设置 $j=m-1$，跳到第2步
5	如果 $A_m<target$ 设置 $i=m+1$，跳到第2步
6	如果 $A_m=target$，结束查找，找到了

分步演示

情况一：能在有序数组找到待查值

1、给定一个有序数组，并且在其下面标上下标。

2、设置一个i值和一个j值，i从数组第0号元素左边开始检索，j从数组最后一个元素右边开始检索。

3、设定一个可以在数组中能找到的数值：36 作为待查值target。接着开始二分查找。首先找第一次的中间索引 m ，使用公式$m=floor(\frac{i+j}{2})$ 可知：m=（0+7）/ 2 = 3.5 ，向下求值后可得m=3。

4、**判断第一次中间索引与待查值的大小。**发现 m 所对应的数为 28，小于待查值 36.就将 i 设置成 m+1 .

5、接着找第二次的中间索引 m ，使用公式$m=floor(\frac{i+j}{2})$ 可知：m=（4+7）/ 2 = 5.5 ，向下求值后可得m=5。

6、**判断第二次中间索引与待查值的大小。**发现 m 所对应的数为 38，大于待查值 36.就将 j 设置成 m-1 .

7、接着找第三次的中间索引 m ，使用公式$m=floor(\frac{i+j}{2})$ 可知：m=（4+4）/ 2 = 4 .

8、**判断第三次中间索引与待查值的大小。**发现 m 所对应的数为 36，等于待查值 36.到这里我们就通过二分查找找到了待查值。

情况二：不能在有序数组找到待查值

1、给定一个有序数组，并且在其下面标上下标。【与上同】

2、设置一个i值和一个j值，i从左边开始检索，j从右边开始检索。【与上同】

3、设定一个可以在数组中能呗找到的数值：26 作为待查值target。接着开始二分查找。首先找第一次的中间索引 m ，使用公式$m=floor(\frac{i+j}{2})$ 可知：m=（0+7）/ 2 = 3.5 ，向下求值后可得m=3。【与上同】

4、**判断第一次中间索引与待查值的大小。**发现 m 所对应的数为 28，大于待查值 26.就将 j 设置成 m-1 .

5、接着找第二次的中间索引 m ，使用公式$m=floor(\frac{i+j}{2})$ 可知：m=（0+2）/ 2 = 1 .

6、**判断第二次中间索引与待查值的大小。**发现 m 所对应的数为 12，小于待查值 36.就将 i 设置成 m+1 .

7、接着找第三次的中间索引 m ，使用公式$m=floor(\frac{i+j}{2})$ 可知：m=（2+2）/ 2 = 2 .

8、**判断第三次中间索引与待查值的大小。**发现 m 所对应的数为 20，小于待查值 36.我们再次将 i 设置成 m+1 .

9、到这里我们能发现 i 已经大于 j ，能够证明我们找不到了，到此结束查找.

P.S.

• 对于一个算法来讲，都有较为严谨的描述，上面是一个例子
• 后续讲解时，以简明直白为目标，不会总以上面的方式来描述算法

翻译成代码

以：情况一：能在有序数组找到待查值 进行演示

1、给定一个有序数组。

【这一步可以通过测试代码进行测试、输出，放到后面去详细解释】

2、设置一个i值和一个j值，i从左边开始检索，j从右边开始检索。

这句话可以翻译成以下代码：

int i = 0;
int j = a.length - 1;

3、设定一个可以在数组中能找到的待查值target。接着开始二分查找。首先找中间索引 m ，使用公式$m=floor(\frac{i+j}{2})$ 。在java中， int m = (i+j) / 2 ; 会自动地向下取整。

这句话可以翻译成以下代码：

while(i <= j)   //只有在i <= j中，才可以通过二分查找找到数值
        {
            int m = (i+j) / 2 ;
        }
return -1； //当i > j中，就证明无法找到了

4、**判断中间索引与待查值的大小。**发现 m 小于待查值就将 **i 设置成 m+1 .**若发现 m 大于待查值 36.就将 j 设置成 m-1 .如果发现 m 等于待查值就证明找到了，直接返回m值即可。

这句话可以翻译成以下代码：

if(a[m] > target) //目标待查值在m的左边
            {
                j = m - 1;
            }
            else if (a[m] < target)//目标待查值在m的右边
            {
                i = m + 1;
            }
            else //目标待查值等于m，证明找到了
            {
                return m;
            }

基础版代码（包括测试类）

本代码仍然可以正常运行，不过如果想有更好更优化的代码可以向下继续观看。

public class 二分查找 {
    public static int binarySearch(int[] a, int target) {
        int i = 0;
        int j = a.length - 1;
        while(i <= j)   //只有在i <= j中，才可以通过二分查找找到数值
        {
            int m = (i+j) / 2 ; //这里有点小问题，但不影响代码运行，具体可以跳到《疑惑解答》去了解
            if(a[m] > target) //目标待查值在m的左边
            {
                j = m - 1;
            }
            else if (a[m] < target)//目标待查值在m的右边
            {
                i = m + 1;
            }
            else //目标待查值等于m，证明找到了
            {
                return m;
            }
        }
        return -1;  //当i > j中，就证明无法找到了
    }
}

同时你也可以自己写一个junit测试类，来测试这段代码是否能正常运行：

package SuanFa.test;

import org.junit.jupiter.api.DisplayName;

import SuanFa.第一章_初始算法.数组.二分查找;

import static org.junit.jupiter.api.Assertions.*;

class 二分查找Test {

    @org.junit.jupiter.api.Test
    @DisplayName("binarySearch 找到！")
    void testbinarySearch() {
        int[] a = {7, 13, 24, 45, 66, 82, 94};
        assertEquals(0,二分查找.binarySearch(a, 7));
    }
}

然后发现测试是正常可运行的，证明我们代码暂时没有出现问题。

疑惑解答

问：那为什么是i<=j 意味着区间内有未比较的元素，而不是 i<j ？
答：因为 i , j 它们指向的元素也会参与比较

问：使用 (i+j) / 2 会不会出现问题呢？

答：第一段代码中，计算m的方式是(i+j) / 2，这是整数除法，会直接舍去小数部分。这种方式在m恰好是两个整数的中间值时可能会导致问题，因为如果i和j都是奇数，那么m就会偏向于左边，导致可能无法找到目标值。

​ 所以我们可以进行一个改良，把计算m的方式改成(i + j) >>> 1，这是无符号右移操作，可以保证无论i和j的值如何，m都会取到它们中间位置的整数。这种方式可以避免上述问题。

基础版改良后代码

public static int binarySearch(int[] a, int target) {
    int i = 0, j = a.length - 1;
    while (i <= j) {
        int m = (i + j) >>> 1; // 可以避免m找不到中间值的问题
        if (target < a[m]) {			// 在左边
            j = m - 1;
        } else if (a[m] < target) {		// 在右边
            i = m + 1;
        } else {
            return m;
        }
    }
    return -1;
}

进阶版

进阶版相对于基础版，会进行三个地方的改动：

改动地方

改动一：i 跟 j 的边界位置

不希望j指的区域参与比较运算

int i = 0;
int j = a.length;

改动二：while 的条件

 while(i < j)   
        {
         	……
        }

改动三：if 判断中的 j 的边界问题

if(a[m] > target) 
            {
                j = m;
            }

改动后代码

package SuanFa.第一章_初始算法.数组;

public class 二分查找 {
    public static int binarySearch(int[] a, int target) {
        int i = 0;
        int j = a.length;
        while(i < j)   
        {
            int m = (i+j) >>> 1 ;
            if(a[m] > target)
            {
                j = m;
            }
            else if (a[m] < target)
            {
                i = m + 1;
            }
            else 
            {
                return m;
            }
        }
        return -1;
    }
}

分步演示

1、给定一个有序数组，并且在其下面标上下标。并设置一个i值和一个j值，i从数组第0个元素开始向左检索，j从外界区域开始向右检索。

2、设定一个可以在数组中能找到的数值：26 作为待查值target。接着开始二分查找。首先找第一次的中间索引 m ，使用公式$m=floor(\frac{i+j}{2})$ 可知：m=（0+8）>>> 1 = 4

3、**判断第一次中间索引与待查值的大小。**发现 m 所对应的数为 33，大于待查值 26.就将 j 设置成 m .

4、接着找第二次的中间索引 m ，使用公式$m=floor(\frac{i+j}{2})$ 可知：m=（0+4）>>> 1= 2.

5、**判断第二次中间索引与待查值的大小。**发现 m 所对应的数为 20，小于待查值 26.就将 i 设置成 m+1 .

6、接着找第三次的中间索引 m ，使用公式$m=floor(\frac{i+j}{2})$ 可知：m=（3+4）>>> 1 = 3 .（向下求值）

7、**判断第三次中间索引与待查值的大小。**发现 m 所对应的数为 26，等于待查值 26.到这里我们就通过二分查找找到了待查值。

改动地方的解释

i 跟 j 的边界位置改动原因

改动原因：不希望 j 指的区域参与比较运算，j 只需要作为 a.length ，下标为8 的元素即可

while 的条件改动原因

改动原因：i 的区域是要参与比较运算的，而 j 不需要。如果出现等于号，就有可能出现 i 带着 j 一起进行运算了。

注：当仅修改了 j = a.length 的条件，却没有改动 while 中 i <= j ，在查找数组中不存在的元素的话，就会发生死循环！

示例：

1、给定一个有序数组，并且在其下面标上下标。并设置一个i值和一个j值，i从数组第0个元素开始向左检索，j从外界区域开始向右检索。

2、设定一个可以在数组中找不到的数值：27 作为待查值target。接着开始二分查找。首先找第一次的中间索引 m ，使用公式$m=floor(\frac{i+j}{2})$ 可知：m=（0+8）>>> 1 = 4

3、**判断第一次中间索引与待查值的大小。**发现 m 所对应的数为 33，大于待查值 27.就将 j 设置成 m .

4、接着找第二次的中间索引 m ，使用公式$m=floor(\frac{i+j}{2})$ 可知：m=（0+4）>>> 1= 2.

5、**判断第二次中间索引与待查值的大小。**发现 m 所对应的数为 20，小于待查值 27.就将 i 设置成 m+1 .

6、接着找第三次的中间索引 m ，使用公式$m=floor(\frac{i+j}{2})$ 可知：m=（3+4）>>> 1 = 3 .（向下求值）

7、**判断第三次中间索引与待查值的大小。**发现 m 所对应的数为 26，小于待查值 27.再将 i 设置成 m+1 .

8、接着找第四次的中间索引 m ，使用公式$m=floor(\frac{i+j}{2})$ 可知：m=（4+4）>>> 1 = 4 .

9、**判断第四次中间索引与待查值的大小。**发现 m 所对应的数为 33，大于待查值 27.再将 **j 设置成 m .**但由于原本的 j 就在下标为4的位置，此时就开始陷入死循环里了。

if 判断中的 j 的边界问题改动原因

改动三就很简单了，这里就不多赘述了。

衡量算法好坏

时间复杂度

下面的查找算法也能得出与之前二分查找一样的结果，那你能说出它差在哪里吗？

public static int search(int[] a, int k) {
    for (
        int i = 0;
        i < a.length;
        i++
    ) {
        if (a[i] == k) {
            return i;
        }
    }
    return -1;
}

考虑最坏情况下（没找到）例如 [1,2,3,4] 查找 5

• int i = 0 只执行一次
• i < a.length 受数组元素个数 $n$ 的影响，比较 $n+1$ 次
• i++ 受数组元素个数 $n$ 的影响，自增 $n$ 次
• a[i] == k 受元素个数 $n$ 的影响，比较 $n$ 次
• return -1，执行一次

粗略认为每行代码执行时间是 $t$，假设 $n=4$ 那么

• 总执行时间是 $(1+4+1+4+4+1)\ast t=15t$
• 可以推导出更一般地公式为，$T=(3\ast n+3)t$

如果套用二分查找算法，还是 [1,2,3,4] 查找 5

public static int binarySearch(int[] a, int target) {
    int i = 0, j = a.length - 1;
    while (i <= j) {
        int m = (i + j) >>> 1;
        if (target < a[m]) {			// 在左边
            j = m - 1;
        } else if (a[m] < target) {		// 在右边
            i = m + 1;
        } else {
            return m;
        }
    }
    return -1;
}

• int i = 0, j = a.length - 1 各执行 1 次

• i <= j 比较 $floor({\log }_2(n)+1)$ 再加 1 次

• (i + j) >>> 1 计算 $floor({\log }_2(n)+1)$ 次

• 接下来 if() else if() else 会执行 $3\ast floor({\log }_2(n)+1)$ 次，分别为

  • if 比较
  • else if 比较
  • else if 比较成立后的赋值语句

• return -1，执行一次

结果：

• 总执行时间为 $(2+(1+3)+3+3\ast 3+1)\ast t=19t$
• 更一般地公式为 $(4+5\ast floor({\log }_2(n)+1))\ast t$

注意：

左侧未找到和右侧未找到结果不一样，这里不做分析

两个算法比较，可以看到 $n$ 在较小的时候，二者花费的次数差不多

但随着 $n$ 越来越大，比如说 $n=1000$ 时，用二分查找算法（红色）也就是 $54t$，而蓝色算法则需要 $3003t$

计算机科学中，时间复杂度是用来衡量：一个算法的执行，随数据规模增大，而增长的时间成本

• 不依赖于环境因素

如何表示时间复杂度

• 假设算法要处理的数据规模是 $n$，代码总的执行行数用函数 $f(n)$ 来表示，例如：

  • 线性查找算法的函数 $f(n)=3\ast n+3$
  • 二分查找算法的函数 $f(n)=(floor(lo{g}_2(n))+1)\ast 5+4$

• 为了对 $f(n)$ 进行化简，应当抓住主要矛盾，找到一个变化趋势与之相近的表示法

大 $O$ 表示法

其中

• $c,c_1,c_2$ 都为一个常数
• $f(n)$ 是实际执行代码行数与 n 的函数
• $g(n)$ 是经过化简，变化趋势与 $f(n)$ 一致的 n 的函数

渐进上界

渐进上界（asymptotic upper bound）：从某个常数 $n_0$开始，$c\ast g(n)$ 总是位于 $f(n)$ 上方，那么记作 $O(g(n))$

• 代表算法执行的最差情况

例1：

• $f(n)=3\ast n+3$
• $g(n)=n$
• 取 $c=4$，在$n_0=3$ 之后，$g(n)$ 可以作为 $f(n)$ 的渐进上界，因此表示法写作 $O(n)$

例2：

• $f(n)=5\ast floor(lo{g}_2(n))+9$
• $g(n)=lo{g}_2(n)$
• $O(lo{g}_2(n))$

已知 $f(n)$ 来说，求 $g(n)$

• 表达式中相乘的常量，可以省略，如
  • $f(n)=100\ast n^2$ 中的 $100$
• 多项式中数量规模更小（低次项）的表达式，如
  • $f(n)=n^2+n$ 中的 $n$
  • $f(n)=n^3+n^2$ 中的 $n^2$
• 不同底数的对数，渐进上界可以用一个对数函数 $\log n$ 表示
  • 例如：$lo{g}_2(n)$ 可以替换为 $lo{g}_{10}(n)$，因为 $lo{g}_2(n)=\frac{lo{g}_{10}(n)}{lo{g}_{10}(2)}$，相乘的常量 $\frac{1}{lo{g}_{10}(2)}$ 可以省略
• 类似的，对数的常数次幂可省略
  • 如：$log(n^c)=c\ast log(n)$

常见大 $O$ 表示法

按时间复杂度从低到高

• 黑色横线 $O(1)$，常量时间，意味着算法时间并不随数据规模而变化
• 绿色 $O(log(n))$，对数时间
• 蓝色 $O(n)$，线性时间，算法时间与数据规模成正比
• 橙色 $O(n\ast log(n))$，拟线性时间
• 红色 $O(n^2)$ 平方时间
• 黑色朝上 $O(2^n)$ 指数时间
• 没画出来的 $O(n!)$ ☞ 指n的阶乘，是时间复杂度最大的

渐进下界

渐进下界（asymptotic lower bound）：从某个常数 $n_0$开始，$c\ast g(n)$ 总是位于 $f(n)$ 下方，那么记作 $\Omega (g(n))$

渐进紧界

渐进紧界（asymptotic tight bounds）：从某个常数 $n_0$开始，$f(n)$ 总是在 $c_1\ast g(n)$ 和 $c_2\ast g(n)$ 之间，那么记作 $\Theta (g(n))$

空间复杂度

与时间复杂度类似，一般也使用大 $O$ 表示法来衡量：一个算法执行随数据规模增大，而增长的额外空间成本*（额外指的是原始数据所占的空间不用算）

public static int binarySearchBasic(int[] a, int target) {
    int i = 0, j = a.length - 1;    // 设置指针和初值
    while (i <= j) {                // i~j 范围内有东西
        int m = (i + j) >>> 1;
        if(target < a[m]) {         // 目标在左边
            j = m - 1;
        } else if (a[m] < target) { // 目标在右边
            i = m + 1;
        } else {                    // 找到了
            return m;
        }
    }
    return -1;
}

二分查找性能

下面分析二分查找算法的性能

时间复杂度

• 最坏情况：$O(\log n)$
• 最好情况：如果待查找元素恰好在数组中央，只需要循环一次 $O(1)$

空间复杂度

• 需要常数个指针 $i,j,m$，因此额外占用的空间是 $O(1)$

平衡版

与前面的基础版与进阶版不同的是：只用 if-else 即可

public static int binarySearchBalance(int[] a, int target) {
    int i = 0, j = a.length;
    while (1 < j - i) {
        int m = (i + j) >>> 1;
        if (target < a[m]) {
            j = m;
        } else {
            i = m;
        }
    }
    return (a[i] == target) ? i : -1;
}

思想：

1. 左闭右开的区间，$i$ 指向的可能是目标，而 $j$ 指向的不是目标
2. 不奢望循环内通过 $m$ 找出目标, 缩小区间直至剩 1 个, 剩下的这个可能就是要找的（通过 $i$）
   • $j-i>1$ 的含义是，在范围内待比较的元素个数 > 1
3. 改变 $i$ 边界时，它指向的可能是目标，因此不能 $m+1$
4. 循环内的平均比较次数减少了
5. 时间复杂度 $\Theta (log(n))$

算法题实战：力扣704 . 二分查找

具体的解题过程可以跳转到我的另一篇博客进行观看：代码随想录—力扣算法题：704二分查找.Java版（示例代码与导图详解）