二分查找边界情况分析

最近在刷Leetcode的时候，发现许多题目的解法都用到了二分查找的变种，个人感觉这些变种有一个共性，就是边界情况比较难考虑周全。一些细节每次都要重新想一遍，比较费时间。归根结底还是基本的二分查找没理解透彻，借此机会彻底分析一下二分查找的各种边界情况。

 

先贴一段正确的二分查找代码。

这段代码从list中查找target的位置，如果找到target，将其位置存放在index中，l和r分别为查找范围的左右边界。

public class Main {

    public static void main(String[] args) {
        int[] list = new int[] {1, 2, 3, 4, 5, 6, 7, 8};
        int target = 3;
        int index = -1;
        
        int l = 0;
        int r = list.length - 1;
        
        while(l <= r) {
            int mid = (l + r) / 2;
            if (list[mid] < target) {
                l = mid + 1;
            } else if (list[mid] > target) {
                r = mid - 1;
            } else {
                index = mid;
                break;
            }
        }
        System.out.println(index);
    }
}

我们以问题的形式来探索这段代码：

1. 右边界r可不可以设为list.length？

public class Main {

    public static void main(String[] args) {
        int[] list = new int[] {1, 2, 3, 4, 5, 6, 7, 8};
        int target = 9;
        int index = -1;

        int l = 0;
        int r = list.length;

        while(l <= r) {
            int mid = (l + r) / 2;
            if (list[mid] < target) {
                l = mid + 1;
            } else if (list[mid] > target) {
                r = mid - 1;
            } else {
                index = mid;
                break;
            }
        }
        System.out.println(index);
    }
}

这时候我们会发现，找9的时候会出现下标越界的问题，因为l和r最后都跑到了list.length的位置：

（首行为数组中的值，非下标，x为数组外的位置，用于演示，并非数组成员）

    1    2    3    4    5    6    7    8      x
    l                   m                     r
                             l    m           r
                                       l/m    r
                                              l/r/m

该情况下，找大于8的数都会出现同样的问题。这时候我们有一个解决方案，就是将while的判断条件从 l <= r 修改为 l < r，这样数组就不会越界访问元素，这就引出了第二个问题：

 

2. while的判断条件可不可以把等于的情况去掉？

public class Main {

    public static void main(String[] args) {
        int[] list = new int[] {1, 2, 3, 4, 5, 6, 7, 8};
        int target = 6;
        int index = -1;

        int l = 0;
        int r = list.length;

        while(l < r) {
            int mid = (l + r) / 2;
            if (list[mid] < target) {
                l = mid + 1;
            } else if (list[mid] > target) {
                r = mid - 1;
            } else {
                index = mid;
                break;
            }
        }
        System.out.println(index);
    }
}

找大于8的数时确实都正常了，但是引出了另一个问题，找6的时候会找不到：

​    1    2    3    4    5    6      7    8    x
    l                   m                     r
                             l      m         r
                             l/r    

该运行过程中我们看到，找到6时l与r刚好重合，但是while的判断条件变成了l < r，在判断值之前就跳出了循环。注意即使在右边界r不更改的情况下，修改while的判断条件依然会导致该问题。这时候我们把目光转向r的更新上，我们将 r = mid - 1 更换为 r = mid，问题解决了。这时候我们得到了一个看似正确的二分查找程序，具体是不是需要继续分析。

public class Main {

    public static void main(String[] args) {
        int[] list = new int[] {1, 2, 3, 4, 5, 6, 7, 8};
        int target = 5;
        int index = -1;

        int l = 0;
        int r = list.length;

        while(l < r) {
            int mid = (l + r) / 2;
            if (list[mid] < target) {
                l = mid + 1;
            } else if (list[mid] > target) {
                r = mid;
            } else {
                index = mid;
                break;
            }
        }
        System.out.println(index);
    }
}

该程序的正确性有带证明，但是对右边界r更新语句的修改引出了一个新的问题：基于第一个正确的二分查找程序，r更新时跳到mid的左边跟跳到mid位置有没有区别？

 

3. 右边界r的更新语句可否替换为r = mid？

正确的二分查找程序中，r = mid - 1看起来只是一个优化，因为list[mid]不可能是我们要找的数了，所以通过减1来略过该位置。但是这么说来，r = mid看起来也没错，无非就是把不可能的数包含在了搜索范围内，整体搜索范围还是在缩小的。但事实并不是这样：

public class Main {

    public static void main(String[] args) {
        int[] list = new int[] {1, 2, 3, 4, 5, 6, 7, 8};
        int target = 0;
        int index = -1;

        int l = 0;
        int r = list.length - 1;

        while(l <= r) {
            int mid = (l + r) / 2;
            if (list[mid] < target) {
                l = mid + 1;
            } else if (list[mid] > target) {
                r = mid;
            } else {
                index = mid;
                break;
            }
        }
        System.out.println(index);
    }
}

修改为r = mid后，我们搜0的时候出现了死循环，原因看如下的执行过程便知：

    1      2    3    4    5    6      7    8
    l                m                     r
    l      m         r      
    l/m    r
    l/r/m

最后l和r重叠时，r的位置无法再变化了，所以r = mid这个修改只适用于上一个情况。

（未完待续）