查找

线性查找

package calculate;

public class SeqSearch {

	//线性查找
	public static void main(String[] args) {
		int[] arr = {-1,34,89};
		System.out.println(seqSearch(arr, 34));

	}
	public static int seqSearch(int[] arr,int value) {
		for (int i = 0; i < arr.length; i++) {
			if (arr[i] == value) {         //找到一个就返回
				return i;
			}
		}
		return -1;
	}

}
//输出
1

二分查找

在一个有序数组进行查找

package calculate;

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

public class BinarySearch {

	//二分查找
	public static void main(String[] args) {
		int[] arr = {11,22,33,44,55,66,66};
		System.out.println(binarySearch2(arr, 0, arr.length-1, 66));
	}
	
	//二分查找（有序的，没有重复的）
	/**
	 * @param arr    数组
	 * @param left    左索引
	 * @param right   右索引
	 * @param value    查找的值
	 * @return       找到就返回下标，没找到就返回-1
	 */
	public static int binarySearch(int[] arr,int left,int right,int value) {
		
		if (left > right) {    //没找到就结束递归
			return -1;
		}
		int mid = (left + right)/2;
        //int mid = left + (right-left)>>2;避免溢出，效率高
		if (arr[mid] < value) {//在右边找
			//向右递归
			return binarySearch(arr, mid + 1, right, value);
		}else if (arr[mid] > value) {        //在左边找
			return binarySearch(arr, left, mid-1, value);
		}else {
			return mid;           //找到了，恰好就是中间的
		}
	}
	
	//二分查找升级版（有重复的元素）
	public static ArrayList<Integer> binarySearch2(int[] arr,int left,int right,int value) {
		
		if (left > right) {    //没找到就结束递归
			return new ArrayList<Integer>();
		}
		int mid = (left + right)/2;
		if (arr[mid] < value) {//在右边找
			//向右递归
			return binarySearch2(arr, mid + 1, right, value);
		}else if (arr[mid] > value) {        //在左边找
			return binarySearch2(arr, left, mid-1, value);
		}else {
			//1.再找到mid值，不要直接返回
			//2.向mid索引值的左边扫描，将所有满足的元素下标加入到ArrayList
			//3.向mid索引值的右边扫描，将所有的加入ArrayList
			ArrayList<Integer> list = new ArrayList<Integer>();
			
			int temp = mid -1;
			while (true) {       //向左扫描
				if (temp < 0 || arr[temp] != value) {  //退出
					break;
				}
				//否则就放入集合
				list.add(temp);      //自动装箱
				temp -=1;     //temp左移
			}
			
			list.add(mid);   //将找到的加入
			int temp2 = mid + 1;
			while (true) {       //向右扫描
				if (temp2 > arr.length-1 || arr[temp2] != value) {  //退出
					break;
				}
				//否则就放入集合
				list.add(temp2);      //自动装箱
				temp2 +=1;     //temp左移
			}
			return list;

		}
	}
}

插值查找

package calculate;

import java.util.Arrays;

public class InsertValueSearch {
	
	public static void main(String[] args) {
		int[] arr = new int[100];
		for (int i = 0; i < arr.length; i++) {
			arr[i] = i+1;
		}
		
		System.out.println(insertValueSearch(arr, 0, arr.length-1, 99));
	}
	
	//插值查找(有序的)
	/**
	 * @param arr
	 * @param left
	 * @param right
	 * @param value  查找的值
	 * @return  索引
	 */
	public static int insertValueSearch(int[] arr,int left,int right,int value) {
		//必须要，否则得到的mid可能越界
		if (left > right ||	value < arr[0] ||value > arr[arr.length-1] ) {
			return -1;
		}
		
		//求出mid
		int mid = left + (right - left)*(value - arr[left])/(arr[right]-arr[left]);
		int midValue = arr[mid];
		if(value > midValue) {   //向右递归
			return insertValueSearch(arr, mid+1, right, value);
		}else if (value < midValue) {//向左递归
			return insertValueSearch(arr, left, mid-1, value);
		}else {
			return mid;
		}
	}
}

对于数据量较大，关键字分布比较均匀的查找表来说，采用插值查找，速度较快。

关键字分布不均匀的时候，不一定比二分查找好。

斐波那契查找

package calculate;

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};
		System.out.println(fibonacciSearch(arr, 1));
		

	}
	//先获取到斐波那契数列
	public static int[] fib() {
		int[] f = new int[maxSize];
		f[0] = 1;
		f[1] = 1;
		for (int i = 2; i < f.length; i++) {
			f[i] = f[i-1] + f[i-2];
		}
		return f;
	}
	//斐波那契查找算法（非递归）
	/**
	 * @param a
	 * @param key    需要查找的值
	 * @return       值的索引，如果没有返回-1
	 */
	public static int fibonacciSearch(int[] a,int key) {
		int low = 0;
		int high = a.length-1;
		int k = 0;     //表示斐波那契分割数值的下标
		int mid = 0;
		int f[] = fib();
		//获取到斐波那契数列分割数值下标k
		while (high > f[k]-1) {       //说明没有找到
			k++;
		}
		//因为f[k]可能大于数组a的长度,因此我们需要使用Arrays类，构造一个新的数组，并指向temp[]
		int[] temp = Arrays.copyOf(a, f[k]);  //不足的部分使用0填充，f[k]为数组长度
		//实际上使用a数组最后的数填充temp
		for (int i = high+1; i < temp.length; i++) {
			temp[i] = a[high];
		}
		//使用while来循环处理，找到key
		while(low <= high) {      //只要满足就可以找
			mid = low + f[k-1] - 1;
			if (key < temp[mid]) {  //向左边查找
				high = mid - 1;
				k--;
				//全部元素=前面元素 + 后面元素
				//f[k] = f[k-1] + f[k-2],即在前面有f[k-1]个元素
				//所以继续拆分f[k-1] = f[k-2] + f[k-3]
				
			}else if (key > temp[mid]) {   //向右边查找
				low = mid + 1;
				k -= 2;
				//全部元素=前面元素 + 后面元素
				//f[k] = f[k-1] + f[k-2],即在后面有f[k-2]个元素
			}else {
				if (mid <= high) {
					return mid;
				}else {
					return high;
				}
			}
		}
		return -1;
	}
}