二分查找算法（Java）

二分查找算法也叫做折半查找，它是一种效率较高的查找方法，但是，二分查找有一个大前提，它要求线性表必须是采用顺序存储的方式，且表中的元素是有序排列的，

本文将讲解二分查找的递归和非递归的两种写法，并改进二分查找（即在一个有序数组中，当有多个相同的数值时，如何将这些数值都查到？）二分查找算法采用非递归要比用递归好。

话不多说，直接上代码：

递归代码

/**
	 * 
	 * @param arr
	 *            数组
	 * @param left
	 *            左边的索引
	 * @param right
	 *            右边的索引
	 * @param findVal
	 *            要查找的值
	 * @return 如果找到要查找的值，就返回其坐标，如果找不到，就返回-1
	 */
public static int binarySearch(int[] arr, int left, int right, int findVal) {
            // 当left>right时，说明递归整个数组，但没有找到
            if (left > right) {
                  return -1;
            }
            int mid = (left + right) / 2;
            int midVal = arr[mid];
            if (findVal > midVal) {// 向右递归
                  return binarySearch(arr, mid + 1, right, findVal);
            } else if (findVal < midVal) {// 向左递归
                  return binarySearch(arr, left, mid - 1, findVal);
            } else {
                  return mid;
            }
      }

非递归代码：

 //二分查找算法非递归写法
      public static int binarySearch1(int[] arr,int target){
            int left = 0;
            int right = arr.length-1;
            while (left<=right) {//说明继续查找
                  int mid = (left+right)/2;
                  if(arr[mid]==target){
                        return mid;
                  }else if (arr[mid]>target) {
                        right = mid-1;
                  }else {
                        left=mid+1;
                  }
            }
            return -1;
      }

改进后的二分查找

/*
	 * 改进二分查找，思考：当一个有序数组中，有多个相同的数值时，如何将所有的数值都查找到，
	 * 
	 * 思路分析：
	 *  1.在找到mid索引值，不要马上返回
	 *  2.向mid索引值的左边扫描，将所有要查找的相同数值的元素下标都加入到集合ArrayList
	 * 	3.向mid索引值的右边扫描，将所有要查找的相同数值的元素下标都加入到集合ArrayList 
	 * 	4.将ArrayList返回
	 */

	public static ArrayList<Integer> binarySearch2(int[] arr, int left, int right, int findVal) {

		// 当left>right时，说明递归整个数组，但没有找到
		if (left > right) {
			return new ArrayList<Integer>();
		}
		int mid = (left + right) / 2;
		int midVal = arr[mid];

		if (findVal > midVal) {// 向右递归
			return binarySearch2(arr, mid + 1, right, findVal);
		} else if (findVal < midVal) {// 向左递归
			return binarySearch2(arr, left, mid - 1, findVal);
		} else {
			
			ArrayList<Integer> resIndexlist = new ArrayList<Integer>();
			
			//向mid索引值的左边扫描，将所有要查找的相同数值的元素下标都加入到集合ArrayList
			int temp = mid-1;
			while (true) {
				if (temp<0 || arr[temp]!=findVal){//退出
					break;
				}else {
					//否则，就temp放入到resIndexlist
					resIndexlist.add(temp);
					temp-=1;//temp左移
				}
			}
			resIndexlist.add(mid);
			//向mid索引值的右边扫描，将所有要查找的相同数值的元素下标都加入到集合ArrayList
			temp = mid+1;
			while (true) {
				if (temp>arr.length-1 || arr[temp]!=findVal) {
					break;
				}else {
					resIndexlist.add(temp);
					temp+=1;
				}
			}
			return resIndexlist;
		}
	}

主方法的内容就不粘出来了，可自行测试。二分查找算法相对简单，比较好懂，无论是递归还是非递归，都首先要确定mid的值，即mid = (left + right) / 2。