二分查找算法

1、算法概念
二分查找算法也称为折半搜索、二分搜索，是一种在有序数组中查找某一特定元素的搜索算法。
隐藏条件：二分查找必须是有序的，从小到大，或从大到小的排序才能进行二分查找。
2、算法思想
1.搜素过程先从数组的中间元素开始，如果中间元素正好是要查找的元素，则搜素过程结束；
2.如果某一特定元素大于或者小于中间元素，则在数组大于或小于中间元素的那一半中查找，而且跟开始一样从中间元素开始比较。
3.如果在某一步骤数组为空，则代表找不到。
这种搜索算法每一次比较都使搜索范围缩小一半。
3、实现思路
1.先数组中间的值，并存放在一个变量中（为了下面的说明，变量暂时命名为temp）
2.需要找到的key和temp进行比较；
3.如果key值大于temp，则把数组中间位置作为下一次计算的起点；重复12。
4.如果key值小于temp，则把数组中间位置作为下一次计算的终点；重复123。
5.如果key值等于temp，则返回数组下标，完成查找。

4.代码实现(Java)

package com.algorithm.example;

/**
 * 二分法的实现有多种:一种是递归方式的，一种是非递归方式的
 * @author FX_SKY
 *
 */
public class BinarySearchTest {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		
		int[] arr = {1,3,5,6,8,9,10,12,15};
		int key = 2;
		int index = binarySearch(arr, 0, arr.length, key);
		System.out.println("非递归 index="+index);
		
		index = binarySearch(arr, 0, arr.length, key);
		System.out.println("递归 index="+index);
	}
	
	/**
	 * 非递归实现
	 * @param a
	 * @param fromIndex
	 * @param toIndex
	 * @param key
	 * @return
	 */
	public static int binarySearch(int[] a, int fromIndex, int toIndex, int key) {
	    int low = fromIndex;
	    int high = toIndex;
	    while (low <= high) {
	        int mid = (low + high) >>> 1;
	        int midVal = a[mid];
	        if (midVal < key)
	        	low = mid + 1;
	        else if (midVal > key)
	        	high = mid - 1;
	        else
	        	return mid; // key found
	    }
	    return -(low + 1);  // key not found.
	} 
	
	/**
	 * 递归实现方式
	 * @param array
	 * @param from
	 * @param to
	 * @param key
	 * @return
	 * @throws Exception
	 */
	public static <E extends Comparable<E>> int binarySearch(E[] array, int from, int to, E key) throws Exception {
        if (from < 0 || to < 0) {
            throw new IllegalArgumentException("params from & length must larger than 0 .");
        }
        if (from <= to) {
            int middle = (from + to) >>> 1; // 右移即除2
            E temp = array[middle];
            if (temp.compareTo(key) > 0) {
                to = middle - 1;
            } else if (temp.compareTo(key) < 0) {
                from = middle + 1;
            } else {
                return middle;
            }
        }
        return binarySearch(array, from, to, key);
    }

}

另JDK中已经实现了二分查找的算法，见Arrays.binarySearch(a, fromIndex, toIndex, key, c) 。

5.时间复杂度
假设总共有n个元素，渐渐跟下去就是n,n/2,n/4,....n/2^k，其中k就是循环的次数
由于你n/2^k取整后>=1即令n/2^k=1，可得k=log2n,（是以2为底，n的对数）

所以时间复杂度可以表示O()=O(logn)