查找算法之二分查找思路分析及代码实现

查找算法介绍

在java中，我们常用的查找有四种：

1. 顺序（线性）查找
2. 二分查找/折半查找
3. 插值查找
4. 斐波那契查找

线性查找算法

有一个数列：{1，8，10，89，1000，1234}，判断数列中是否包含此名称【顺序查找】要求：如果找到了，就提示找到，并给出下标值。

二分查找算法

请对一个有序数组进行二分查找{1，8，10，89，1000，1234}，输入一个数看看该数组是否存在此数，并且求出下标，如果没有就提示”没有这个数”。

二分查找算法思路分析

1.首先确定该数组的中间的下标 mid=（left+right）/2
2.然后让需要查找的数findVal和arr[mid]比较
2.1findval>art[mid]，说明你要查找的数在mid的右边，因此需要递归的向右查找
2.2findval<arr[mid]，说明你要查找的数在mid的左边，因此需要递归的向左查找
2.3 findVal==arr[mid]说明找到，就返回

! ! ! 什么时候我们需要结束递归

• 找到就结束递归
• 递归完整个数组，仍然没有找到ndval，也需要结束递归当left>right就需要退出。

代码实现

说明：增加了找到所有的满是条件的元素下标：
课后思题：{1，8，10，89，1000，1000，1234}当一个有序数组中，有多个相同的数值时，如何将所有的数值都查找到，比如这里的1000。

package com.search;

import java.util.ArrayList;
import java.util.List;

public class BinarySearch {

	public static void main(String[] args) {
		int arr[] = { 1, 8, 10, 89, 1000, 1000, 1000, 1234 };
		// int resIndex = binarySearch(arr, 0, arr.length - 1, 89);
		// if (resIndex >= 0) {
		// System.out.println("resIndex=" + resIndex + "(下标)");
		// } else {
		// System.out.println("没有找到" + resIndex);
		// }

		List<Integer> resIndexList = binarySearch2(arr, 0, arr.length - 1, 1000);
		System.out.println("resIndexList=" + resIndexList);
	}

	// 二分查找算法
	/**
	 * 
	 * @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 findVal;
		}

		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;
		}
	}

	// 完成一个课后思考题：
	/*
	 * 课后思考题：{1，8，10，89，1000，1000，1234}当一个有序数组中， 有多个相同的数值时，如何将所有的数值都查找到，比如这里的1000
	 *
	 * 思路分析 1. 在找到mid索引值，不要马上返回 
	 * 2. 向mid 索引值的左边扫描，将所有满足1000，的元素的下标，加入到集合Arraylist 
	 * 3.向mid 索引值的右边扫描，将所有满足1000，的元素的下标，加入到集合Arraylist 
	 * 4. 将Arraylist返回
	 */
	public static List<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 {
			// 思路分析
			// * 1. 在找到mid索引值，不要马上返回
			// * 2. 向mid 索引值的左边扫描，将所有满足1000，的元素的下标，加入到集合Arraylist
			// * 3. 向mid 索引值的右边扫描，将所有满足1000，的元素的下标，加入到集合Arraylist
			// * 4. 将Arraylist返回
			List<Integer> resIndexList = new ArrayList<Integer>();
			// 向mid 索引值的左边扫描，将所有满足1000，的元素的下标，加入到集合Arraylist
			int temp = mid - 1;
			while (true) {
				if (temp < 0 || arr[temp] != findVal) {
					break;
				}
				// 否则，就temp放入到resIndexList
				resIndexList.add(temp);
				temp -= 1;// 左移
			}
			resIndexList.add(mid);

			// 向mid 索引值的右边扫描，将所有满足1000，的元素的下标，加入到集合Arraylist
			temp = mid + 1;
			while (true) {
				if (temp > arr.length - 1 || arr[temp] != findVal) {
					break;
				}
				// 否则，就temp放入到resIndexList
				resIndexList.add(temp);
				temp += 1;// 右移
			}
			return resIndexList;
		}
	}
}