《数据结构与算法》之二分查找

《数据结构与算法》之链表
《数据结构与算法》之链栈
《数据结构与算法》之队列
《数据结构与算法》之排序
《数据结构与算法》之二叉树

二分查找是一种非常简单易懂的快速查找算法，即使你没有写过二分查找的算法，但是二分思想你在生活中肯定会碰到过。比如猜数字的游戏，从1~100中猜一个数字，每猜一次都会告诉你猜大了还是猜小了，直到猜中为止。现在的你是不是已经有思路了。
假如我定的数字是20，按照上面的规则来看下你只需要猜多少次就能够猜中

次数	猜测范围	中间数	对比大小
第一次	1~100	50	50>20
第二次	1~50	25	25>20
第三次	1~25	12	12<20
第四次	12~25	18	18<20
第五次	18~25	21	21>20
第六次	18~21	19	19<20
第七次	19~21	20	20=20

从结果来看，你只需要猜7次就可以猜中，是不是很高效，这就是利用了二分思想的一个典型游戏。
接下来我们看一下代码的实现，举例了五种常见的查找情况。二分查找需要的是一个有序的数组，如果数组元素无序先要排序。先附上demo地址
以下代码low、high、mid 都是指数组下标，其中 low 和 high 表示当前查找的区间范围，初始 low=0， high=n-1。mid 表示[low, high]的中间位置。我们通过对比 a[mid]与 value 的大小，来更新接下来要查找的区间范围，直到找到或者区间缩小为 0，就退出。

1. 查找值等于给定值的元素

    /// 二分查找，一个没有重复数据的有序数组
    /// - Parameters:
    ///   - array: 没有重复数据的有序数组
    ///   - value: 指定的值
    /// - Returns: 位置下标
    class func binarySearch(array: Array<Int>, value: Int) -> Int {
        var low = 0
        var high = array.count - 1
        while low <= high {
            let mid = low + (high - low) >> 1
            if array[mid] == value {
                return mid
            }else if array[mid] > value {
                high = mid - 1
            }else {
                low = mid + 1
            }
        }
        return -1
    }

2. 查找第一个值等于给定值的元素

    /// 二分查找，查找第一个值等于给定值的元素
    /// - Parameters:
    ///   - array: 有序数组
    ///   - value: 指定的值
    /// - Returns: 位置下标
    class func binarySearchFirstEqualToValue(array: Array<Int>, value: Int) -> Int {
        var low = 0
        var high = array.count - 1
        while low <= high {
            let mid = low + (high - low) >> 1
            if array[mid] > value {
                high = mid - 1
            }else if array[mid] < value {
                low = mid + 1
            }else {
                //如果mid等于第一个元素或者mid的前一个元素的值不等于value，就说明是mid所处的位置是第一个值等于给定值的元素
                if mid == 0 || (array[mid - 1] != value) {
                    return mid
                }else {
                    high = mid - 1
                }
            }
        }
        return -1
    }

3. 查找最后一个值等于给定值的元素

	/// 二分查找，查找最后一个值等于给定值的元素
    /// - Parameters:
    ///   - array: 有序数组
    ///   - value: 指定的值
    /// - Returns: 位置下标
    class func binarySearchLastEqualToValue(array: Array<Int>, value: Int) -> Int {
        var low = 0
        var high = array.count - 1
        while low <= high {
            let mid = low + (high - low) >> 1
            if array[mid] > value {
                high = mid - 1
            }else if array[mid] < value {
                low = mid + 1
            }else {
                //如果mid等于第后一个元素或者mid的后一个元素的值不等于value，就说明是mid所处的位置是最后一个值等于给定值的元素
                if (mid == array.count - 1) || (array[mid + 1] != value) {
                    return mid
                }else {
                    low = mid + 1
                }
            }
        }
        return -1
    }

4. 查找第一个大于等于给定值的元素

	/// 二分查找，查找第一个大于等于给定值的元素
    /// - Parameters:
    ///   - array: 有序数组
    ///   - value: 指定的值
    /// - Returns: 位置下标
    class func binarySearchFirstBigToValue(array: Array<Int>, value: Int) -> Int {
        var low = 0
        var high = array.count - 1
        while low <= high {
            let mid = low + (high - low) >> 1
            if array[mid] >= value {
                //如果mid等于第一个元素或者mid的前一个元素的值小于value，就说明是mid所处的位置是第一个值大于等于给定值的元素
                if mid == 0 || (array[mid - 1] < value) {
                    return mid
                }else {
                    high = mid - 1
                }
            }else {
                low = mid + 1
            }
        }
        return -1
    }

5. 查找最后一个小于等于给定值的元素

    /// 二分查找，查找最后一个小于等于给定值的元素
    /// - Parameters:
    ///   - array: 有序数组
    ///   - value: 指定的值
    /// - Returns: 位置下标
    class func binarySearchLastSmallToValue(array: Array<Int>, value: Int) -> Int {
        var low = 0
        var high = array.count - 1
        while low <= high {
            let mid = low + (high - low) >> 1
            if array[mid] <= value {
                if (mid == array.count - 1) || (array[mid + 1] > value) {
                    return mid
                }else {
                    low = mid + 1
                }
            }else {
                high = mid - 1
            }
        }
        return -1
    }

二分查找有3 个容易出错的地方。

1. 循环退出条件
   注意是 low<=high，而不是 low
2. mid 的取值
   实际上，mid=(low+high)/2 这种写法是有问题的。因为如果 low 和 high 比较大的话，两者之和就有可能会溢出。改进的方法是将 mid 的计算方式写成 low+(high-low)/2。更进一步，如果要将性能优化到极致的话，我们可以将这里的除以 2 操作转化成位运算 low+((high-low)>>1)。因为相比除法运算来说，计算机处理位运算要快得多。
3. low 和 high 的更新
   low=mid+1，high=mid-1。注意这里的 +1 和 -1，如果直接写成 low=mid 或者 high=mid，就可能会发生死循环。比如，当 high=3，low=3 时，如果 a[3]不等于 value，就会导致一直循环不退出。