二分查找（下）

       二分查找中最简单的一种情况，在不存在重复元素的有序数组中，查找值等于给定值的元素。 最简单的二分查找写起来确实不难，但是，二分查找的变形问题就没那么好写了。二分查找的变形问题很多。数据是从小到大排列为前提。

变体一：查找第一个值等于给定值的元素

       有序数据集合中存在重复的数据，我们希望找到第一个值等于给定值的数据。

 

     /**
     * 查找第一个值等于给定值的元素，写法一
     * @param a
     * @param n
     * @param value
     * @return
     */
    public int bsearch(int[] a, int n, int value) {
        int low = 0;
        int high = n - 1;
        while (low <= high) {
            int mid = low + ((high - low) >> 1);
            if (a[mid] >= value) {
                high = mid - 1;
                } else {
                low = mid + 1;
                }
            }
        if (low < n && a[low]==value) return low;
        else return -1;
    }

    /**
     * 查找第一个值等于给定值的元素，写法二
     * @param a
     * @param n
     * @param value
     * @return
     */
    public int bsearch1(int[] a, int n, int value) {
        int low = 0;
        int high = n - 1;
        while (low <= high) {
            int mid = low + ((high - low) >> 1);
            if (a[mid] > value) {
                high = mid - 1;
                } else if (a[mid] < value) {
                low = mid + 1;
                } else {
                if ((mid == 0) || (a[mid - 1] != value)) return mid;
                else high = mid - 1;
                }
            }
        return -1;
    }

变体二：查找最后一个值等于给定值的元素

  

/**
     * 查找最后一个值等于给定值的元素
     * @param a
     * @param n
     * @param value
     * @return
     */
public int bsearch2(int[] a, int n, int value) {
        int low = 0;
        int high = n - 1;
        while (low <= high) {
            int mid = low + ((high - low) >> 1);
            if (a[mid] > value) {
                high = mid - 1;
                } else if (a[mid] < value) {
                low = mid + 1;
                } else {
                if ((mid == n - 1) || (a[mid + 1] != value)) return mid;
                else low = mid + 1;
                }
            }
        return -1;
    }

变体三：查找第一个大于等于给定值的元素

/**
     * 查找第一个大于等于给定值的元素
     * @param a
     * @param n
     * @param value
     * @return
     */
    public int bsearch3(int[] a, int n, int value) {
        int low = 0;
        int high = n - 1;
        while (low <= high) {
            int mid = low + ((high - low) >> 1);
            if (a[mid] >= value) {
                if ((mid == 0) || (a[mid - 1] < value)) return mid;
                else high = mid - 1;
                } else {
                low = mid + 1;
                }
            }
        return -1;
    }

变体四：查找最后一个小于等于给定值的元素

/**
     * 查找最后一个小于等于给定值的元素
     * @param a
     * @param n
     * @param value
     * @return
     */
    public int bsearch4(int[] a, int n, int value) {
        int low = 0;
        int high = n - 1;
        while (low <= high) {
            int mid = low + ((high - low) >> 1);
            if (a[mid] > value) {
                high = mid - 1;
                } else {
                if ((mid == n - 1) || (a[mid + 1] > value)) return mid;
                else low = mid + 1;
                }
            }
        return -1;
    }

内容小结

凡是用二分查找能解决的，绝大部分我们更倾向于用散列表或者二叉查找树。即便是二分查找在内存使用上更节省，但是毕竟内存如此紧缺的情况并不多。那二分查找真的没什么用处了吗？ 实际上，“值等于给定值”的二分查找确实不怎么会被用到，二分查找更适合用在“近似”查找问题，在这类问题上，二分查找的优势更加明显。比如今天讲的这几种变体问题，用其他数据结构，比如散列表、二叉树，就比较难实现了。变体的二分查找算法写起来非常烧脑，很容易因为细节处理不好而产生 Bug，这些容易出错的细节有：终止条件、区间上下界更新方法、返回值选择。