二分搜索

在计算机科学中，二分搜索（英语：binary search），也称折半搜索（英语：half-interval search）、对数搜索（英语：logarithmic search），是一种在有序数组中查找某一特定元素的搜索算法。搜索过程从数组的中间元素开始，如果中间元素正好是要查找的元素，则搜索过程结束；如果某一特定元素大于或者小于中间元素，则在数组大于或小于中间元素的那一半中查找，而且跟开始一样从中间元素开始比较。如果在某一步骤数组为空，则代表找不到。这种搜索算法每一次比较都使搜索范围缩小一半。

来自 <https://zh.wikipedia.org/wiki/%E4%BA%8C%E5%88%86%E6%90%9C%E7%B4%A2%E7%AE%97%E6%B3%95>

时间复杂度

折半搜索每次把搜索区域减少一半，时间复杂度为O(log n)。（n代表集合中元素的个数）

空间复杂度

O(1)。虽以递归形式定义，但是尾递归，可改写为循环。

来自 <https://zh.wikipedia.org/wiki/%E4%BA%8C%E5%88%86%E6%90%9C%E7%B4%A2%E7%AE%97%E6%B3%95>

实现：Java版本（循环和递归2个版本）

package com.yan.algorithm;
/**
 * 二分搜索、折半查找：适用于在有序数组中查找某个值，时间复杂度为O(log n),空间复杂度为O(1)
 * @author Yan
 *
 */
public class BinarySearch {

    public BinarySearch() {
    }

    static int[] arr = new int[] { 1, 2, 3, 4, 5, 6, 7 };

    public static void main(String[] args) {
        BinarySearch bSearch = new BinarySearch();
        int rs1 = bSearch.binarySearch(arr, 1);
        int rs2 = bSearch.binarySearch2(arr, 1, 0, arr.length - 1);
        System.out.println(rs1);
        System.out.println(rs2);
    }

    public int binarySearch(int[] arr, int k) {
        if (arr == null) {
            return -1;
        }
        int left = 0;
        int right = arr.length - 1;
        int mid = (left + right) >> 1;
        while (left <= right) {
            if (arr[mid] == k) {
                return mid + 1;
            } else if (k > arr[mid]) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
            // 若为 mid=(left+right)/2，会发生溢出。
//问题会出现在当low+high的结果大于表达式结果类型所能表示的最大值时，这样，产生溢出后再/2是不会产生正确结果的，而low+((high-low)/2)不存在这个问题。
             mid = left + ((right - left) >> 1);
        }

        return -1;
    }

    /**
     * 递归版本
     * 
     * @param arr
     * @param k
     * @param left
     * @param right
     * @return
     */
    public int binarySearch2(int[] arr, int k, int left, int right) {
        if (left > right) {
            return -1;
        }
        // int mid = (right + left) >> 1;
        //// 若为 mid=(left+right)/2，会发生溢出。
//问题会出现在当low+high的结果大于表达式结果类型所能表示的最大值时，这样，产生溢出后再/2是不会产生正确结果的，而low+((high-low)/2)不存在这个问题。
        
        int mid = left + ((right - left) >> 1);
        if (k > arr[mid]) {
            // return 函数自身，则每层都会返回底层所返回的值，所以会返回最后找到的那个mid。
            return binarySearch2(arr, k, mid + 1, right);
        }
        if (k < arr[mid]) {
            return binarySearch2(arr, k, left, mid - 1);
        }
        return mid + 1;
    }
}