二分查找排序(JAVA)

最坏情况： logn

最好情况：O(1)

平均时间复杂度为O(logn)

二分查找也称折半查找，或者对半查找（Binary Search），是一种效率较高的查找方法。

要求： （1）必须采用顺序存储结构 （2）.必须按关键字大小有序排列

将n个元素分成大致相等的两部分，取a[n/2]与x做比较，如果x=a[n/2],则找到x,算法中止；

如果x>a[n/2],则继续在数组a的左半边查找x,如果x

二分查询分循环和递归两种方式：

递归二分查找：

/**
	 * @Descript:递归二分查找(找不到，返回-1，找到的话，返回下标)
	 *
	 * @author LJonah 2018年3月1日
	 * @param array
	 *            数组
	 * @param searchData
	 *            要查找的值
	 * @param begin
	 *            开始位置
	 * @param end
	 *            结束位置
	 * @return
	 */
	public static int recursiveBinarySearch(int[] array, int searchData, int begin, int end) {
		// 如果查找的值比第一个小或者比最后一个大或者起始位置大于结束的位置，表示没找到，返回-1
		if (searchData < array[begin] || searchData > array[end] || begin > end)
		return -1;
		int mid = (begin + end) / 2;
		System.out.println("   mid=" + array[mid]);
		if (array[mid] == searchData)
			return mid;
		else if (array[mid] < searchData)
			return recursiveBinarySearch(array, searchData, mid + 1, end);
		else
			return recursiveBinarySearch(array, searchData, 0, mid);
	}

循环二分查找：

/**
	 * @Descript:循环二分查找(找不到，返回-1，找到的话，返回下标)
	 *
	 * @author LJonah 2018年3月1日
	 * @param array
	 *            数组
	 * @param searchData
	 *            要查找的值
	 * @param begin
	 *            开始位置
	 * @param end
	 *            结束位置
	 * @return
	 */
	public static int loopBinarySearch(int[] array, int searchData, int begin, int end) {
	    int beginIndex = begin;
	    int endIndex = end;
	    //如果查找的值不在数组的范围内，返回-1
	    while(beginIndex <= endIndex && (searchData > array[beginIndex] && searchData < array[endIndex])){
	    	int mid = (beginIndex+endIndex)/2;
	    	System.out.println("   mid="+array[mid]);
	    	//如果查找的值比第一个小或者比最后一个大,表示没找到，返回-1
	    	if(array[mid] == searchData)
	    		return mid;
	    	else if(array[mid] < searchData)
	    		beginIndex = mid+1;
	    	else
	    		endIndex = mid;
	    }
	    return -1;
	}

测试：

public static void main(String[] args) {
		// 要求采用顺序存储结构，要求按关键字大小有序排序
		int[] array = { 0, 3, 4, 8, 9 };
		int searchData =4;
		System.out.println("初始数组：" + Arrays.toString(array) + ";查找值：" + searchData + ";");
		// 递归二分查询
		int index = recursiveBinarySearch(array, searchData, 0, array.length - 1);
		if (index > -1)
			System.out.println(searchData + "在数组" + Arrays.toString(array) + "中的索引是：" + index);
		else
			System.out.println("没找到！");
		// 循环二分查询
		index = loopBinarySearch(array, searchData, 0, array.length - 1);
		if (index > -1)
			System.out.println(searchData + "在数组" + Arrays.toString(array) + "中的索引是：" + index);
		else
			System.out.println("没找到！");

	}

测试结果：

初始数组：[0, 3, 4, 8, 9];查找值：4;
   mid=4
4在数组[0, 3, 4, 8, 9]中的索引是：2
   mid=4
4在数组[0, 3, 4, 8, 9]中的索引是：2