Java算法之查找

查找算法介绍

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

线性查找算法

代码（查找数组中所有该元素的下标）：

import java.util.ArrayList;

public class SeqSearch {

	public static void main(String[] args) {
		int arr[] = { 1, 9, 11, -1, 34, 89, 9 };// 没有顺序的数组
		ArrayList<Integer> index = seqSearch(arr, 9);
		if (index.size() == 0) {
			System.out.println("没有找到到");
		} else {
			System.out.println("找到，下标为=" + index);
		}
	}

	// 这里我们实现的线性查找是找到一个满足条件的值，就返回
	public static ArrayList<Integer> seqSearch(int[] arr, int value) {
		ArrayList<Integer> index = new ArrayList<Integer>();
		// 线性查找是逐一比对，发现有相同值，就返回下标
		for (int i = 0; i < arr.length; i++) {
			if (arr[i] == value) {
				index.add(i);
			}
		}
		return index;
	}
}

二分查找

public class BinarySearch {

	// 前提：该数组必须是有序的
	public static void main(String[] args) {
		int[] arr = { 1, 8, 10, 89, 1000, 1234 };
		int index = binarySearch(arr, 0, arr.length-1, 89);
		if(index!=-1) {
		System.out.println("下标为："+index);
		}else {
		System.out.println("没有查找到该数");
		}
	}
	// 二分查找
	/**
	 * 
	 * @param arr 数组
	 * @param left 左边索引
	 * @param right 右边索引
	 * @param findVal 要查找的值
	 * @return 如果找到则返回下标，没找到则返回-1
	 */
	public static int binarySearch(int[] arr,int left,int right,int findVal) {
		
		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;
		}
	}

结果：

下标为：3

下面我们来进行优化，使其可以查找多个相同的数：

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 };
		List<Integer> indexList = binarySearch2(arr, 0, arr.length - 1, 1000);
		if(indexList.size()==0) {
			System.out.println("没有找到该数");
		}else {
			System.out.println("下标为："+indexList);
		}

	}

	// 二分查找
	public static List<Integer> binarySearch2(int[] arr, int left, int right, int findVal) {

		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 {
			List<Integer> indexList = new ArrayList<Integer>();
			int temp;
			// 向左扫描，将找到的数的下标放入集合中
			temp = mid - 1;
			while (temp >= 0 && arr[temp] == findVal) {
				indexList.add(temp--);
			}
			
			indexList.add(mid);
			
			// 向右扫描，将找到的数的下标放入集合中
			temp = mid + 1;
			while (temp < arr.length && arr[temp] == findVal) {
				indexList.add(temp++);
			}
			return indexList;
		}
	}
}

结果：

下标为：[4, 5, 6]

插值查找

插值查找原理介绍：

1. 插值查找算法类似于二分查找，不同的是插值查找每次从自适应mid处开始查找。

2. 将折半查找中的求mid索引的公式，low 表示左边索引left；high表示右边索引right，key就是前面我们讲的findVal
   

3. int mid = low + (high - low) * (key - arr[low]) / (arr[high] - arr[low])；
   对应前面的代码公式：int mid = left + (right – left) * (findVal – arr[left]) / (arr[right] – arr[left])

对1-100进行插值查找：

代码：

public class InsertValueSearch {

	public static void main(String[] args) {
		
		int[] arr = new int[100];
		for(int i=0;i<100;i++) {
			arr[i]=i+1;
		}
		int index = insertValueSearch(arr, 0, arr.length-1, 69);
		System.out.println("下标为："+index);
	}
	
	//插值查找
	public static int insertValueSearch(int[] arr,int left,int right,int findVal) {
		
		//注：findVal<arr[0] 和 findVal>arr[arr.length-1]必须写，否则可能导致mid越界
		if(left>right || findVal<arr[0] || findVal>arr[arr.length-1]) {
			return -1;
		}
		
		//求出mid
		int mid =  left + (right - left) * (findVal - arr[left]) / (arr[right] - arr[left]);
		int midVal = arr[mid];
		
		if(findVal>midVal) {//向右递归查找
			return insertValueSearch(arr, mid+1, right, findVal);
		}else if(findVal>midVal) {//向左递归查找
			return insertValueSearch(arr, left, mid-1, findVal);
		}else {
			return mid;
		}
	}
}

结果：

下标为：68

注：

1. 若也想实现查找多个相同的数，则根据二分查找一样，进入一个集合进行优化即可。
2. 对于数据量较大，关键字分布比较均匀的查找表来说，采用插值查找, 速度较快。
3. 关键字分布不均匀的情况下，该方法不一定比折半查找要好。

斐波那契查找

斐波那契(黄金分割法)查找基本介绍：

1. 黄金分割点是指把一条线段分割为两部分，使其中一部分与全长之比等于另一部分与这部分之比。取其前三位数字的近似值是0.618。由于按此比例设计的造型十分美丽，因此称为黄金分割，也称为中外比。这是一个神奇的数字，会带来意向不大的效果。
2. 斐波那契数列 {1, 1, 2, 3, 5, 8, 13, 21, 34, 55 } 发现斐波那契数列的两个相邻数 的比例，无限接近黄金分割值0.618。

斐波那契(黄金分割法)原理：
斐波那契查找原理与前两种相似，仅仅改变了中间结点（mid）的位置，mid不再是中间或插值得到，而是位于黄金分割点附近，即mid=low+F(k-1)-1（F代表斐波那契数列），如下图所示：

对F(k-1)-1的理解：

1. 由斐波那契数列 F[k]=F[k-1]+F[k-2] 的性质，可以得到 （F[k]-1）=（F[k-1]-1）+（F[k-2]-1）+1。该式说明：只要顺序表的长度为F[k]-1，则可以将该表分成长度为F[k-1]-1和F[k-2]-1的两段，即如上图所示。从而中间位置为mid=low+F(k-1)-1
2. 类似的，每一子段也可以用相同的方式分割
3. 但顺序表长度n不一定刚好等于F[k]-1，所以需要将原来的顺序表长度n增加至F[k]-1。这里的k值只要能使得F[k]-1恰好大于或等于n即可，由以下代码得到,顺序表长度增加后，新增的位置（从n+1到F[k]-1位置），都赋为n位置的值即可，即：
   
   代码：

import java.util.Arrays;

public class FibonacciSearch {

	public static int maxSize=20;
	public static void main(String[] args) {
		
		int[] arr= {1,8, 10, 89, 1000, 1234};
		int index=fibonacciSearch(arr, 1000);
		if(index!=-1) {
			System.out.println("下标为："+index);
		}else {
			System.out.println("没有找到该数");
		}
	}
	
	//先获取斐波那契数列
	//用非递归的方式
	public static int[] fib() {
		int f[] = new int[maxSize];
		f[0]=1;
		f[1]=1;
		for(int i=2;i<maxSize;i++) {
			f[i]=f[i-1]+f[i-2];
		}
		return f;
	}
	
	//斐波那契查找算法，非递归
	public static int fibonacciSearch(int[] arr,int findVal) {
		int low=0;
		int high=arr.length-1;
		int k=0;//表示斐波那契额分割数值的下标
		int mid=0;
		int f[]=fib();//获取斐波那契数列
		//获取斐波那契分割值的下标
		while(high+1>f[k]-1) {
			k++;
		}
		//由于f[k]的值可能大于数组长度，因此需要用Arrays类来构建一个新数组并指向原数组arr
		//不足的部分会用0填充
		int[] temp = Arrays.copyOf(arr, f[k]);
		//但实际上我们需要的是用数组最后一个数来填充不足的部分
		for(int i=high+1;i<temp.length;i++) {
			temp[i]=arr[high];
		}
		
		//使用while循环来找到待找的数findVal
		while(low<=high) {//只要这个条件满足就可以找
			mid=low+f[k-1]-1;
			if(findVal<temp[mid]) {//向左查找
				high=mid-1;
				//对f[k]中的前一段即f[k-1]再次进行分割，将f[k-1]分割为f[k-2]+f[k-3]
				//即下次循环，时mid=f[k-1-1]-1
				k--;
			}else if(findVal>temp[mid]) {//向右查找
				low=mid+1;
				//对f[k]中的后一段即f[k-2]再次进行分割，将f[k-2]分割为f[k-3]+f[k-4]
				//即下次循环，时mid=f[k-1-2]-1
				k-=2;
			}else {
				if(mid<=high) {
					return mid;
				}else {
					return high;
				}
			}
		}
		return -1;
	}
}

结果：

下标为：4