BinarySearch查找

二分查找
要求： 数组有序
二分查找大大降低了比较次数，二分查找的时间复杂度为：O(log2n)，即log{n}。
假使总共有n个元素，那么二分后每次查找的区间大小就是n，n/2，n/4，…，n/2^k（接下来操作元素的剩余个数），其中k就是循环的次数。
最坏的情况是K次二分之后,每个区间的大小为1,找到想要的元素
令n/2^k=1，
可得k=log2n,（是以2为底，n的对数），所以时间复杂度可以表示O()=O(logn).

package com.lyzz.BinarySearch;

public class BinarySearchDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[] arr= {1,2,3,4,5,6,7,8,9,10};
		int x = BinarySearch1(arr, 3, 0, arr.length-1);
		System.out.println(x);
	}
	
	/**
	 * 递归实现
	 * @author Lxuex
	 * @param arr
	 * @param key
	 * @param low
	 * @param high
	 * @return
	 */
	public static int BinarySearch(int[] arr,int key,int low,int high) {
		if(key < arr[low] || key > arr[high] || low > high) {
			return -1;
		}
		
		int middle = (low + high) / 2;
		if(arr[middle] > key) { //比关键字大在关键字的左边
			return BinarySearch(arr,key,low,middle-1);
			
		}else if(arr[middle] < key) { //比关键字小在关键字的右边
			return BinarySearch(arr,key,middle+1,high);
			
		}else {
			return middle;
		}

	}
	
	/**
	 * 非递归实现
	 * @author Lxuex
	 * @param arr
	 * @param key
	 * @param low
	 * @param high
	 * @return
	 */
	public static int BinarySearch1(int[] arr,int key,int low,int high) {
		while (low <= high)
		{
			int mid = (low + high) / 2; // 取中间位置
			if (key > arr[mid])	   // 从关键字的右半部分继续查找
			{
				low = mid + 1;
			}
			else if (key < arr[mid]) // 从关键字的左半部分继续查找
			{
				high = mid - 1;
			}
			else if (key == arr[mid])
			{
				return mid; // 查找成功，则返回所在位置
			}
		}
		return -1; // 查找元素不存在，返回-1

	}
	

}

二维数组的二分查找：

/**
	 * 二分查找
	 * @param array
	 * @param target
	 * @return
	 */
	 public static boolean Find(int [][] array,int target) {
	        //二维数组的行数
	        int n=array.length-1;
	        //二维数组的索引
	        int i=0; 
	        //从左下角开始遍历
	        while(n>=0&&i<array[n].length){
	            //如果相等，直接返回true
	            //如果小于，二维索引++
	            //如果大于，一维索引—-
	            if(array[n][i]==target){
	                return true;
	            }else if(array[n][i]<target){
	                i++; 
	            }else {
	                n--;
	            }

	        }
	        //循环能够执行完毕，直接返回false
	        return false;

	    }