Java--查找算法

Java–查找算法

（1）线性查找

直接从数组头到尾遍历查找

结束条件（1）找到要查找的值

（2）数组遍历完了还没找到要查找的值

public class Search 
{
	public static void main(String[] args) 
	{
		int [] arr = new int[] {2, 34, 56, 21, 12};//数组
		int index = seqSearch(arr, 12);//线性查找
		if (index == -1)
		{
			System.out.println("没有找到！");
		}
		else
		{
			System.out.println("找到，下标为" + index);
		}
	}
    /**
	 * 线性查找
	 * @param arr数组
	 * @param value要查找的值
	 * @return
	 */
	public static int seqSearch(int [] arr, int value)
	{
		int len = arr.length;//数组长度
		for (int i = 0; i < len; i++)//遍历数组
		{
			if (value == arr[i])//找到
			{
				return i;
			}
		}
		return -1;//没找到
	}
}

---

（2）二分查找

1、left（左索引），right（右索引），mid =（left + right）/ 2，value（要查找的值）；

2、（1）value = arr[mid]，return mid；

（2）value > arr[mid]，右递归

（3）value < arr[mid]，左递归

import java.util.ArrayList;
import java.util.List;
public class Search 
{
	public static void main(String[] args) 
	{
		int [] arr = new int[] {2, 12, 21, 35, 35, 35, 57};//数组
		List<Integer> index = binarySearch(arr, 0, arr.length - 1, 22);//二分查找
		if (index == null)
		{
			System.out.println("没有找到！");
		}
		else
		{
			System.out.println("找到，下标为" + index);
		}
	}
	/**
	 * 二分查找
	 * @param arr数组
	 * @param left左边的索引
	 * @param right右边的索引
	 * @param value要查找的值
	 * @return
	 */
	public static List<Integer> binarySearch(int [] arr, int left, int right, int value)
	{
		if (left > right)//数组遍历完了还没找到要查找的值
		{
			return null;
		}
		int mid = (left + right) / 2;//中间值
		if (value > arr[mid])//右递归
		{
			return binarySearch(arr, mid + 1, right, value);
		}
		else if (value < arr[mid])//左递归
		{
			return binarySearch(arr, left, mid - 1, value);
		}
		else
		{//处理多个相同值情况，如果不用直接写return mid即可
			List<Integer> list = new ArrayList<Integer>();
			int templ = mid - 1;
			while (templ >=0 && arr[templ] == value)//从mid位置向左找相同值
			{
				templ--;
			}
			int tempr = mid + 1;
			while (tempr < arr.length && arr[tempr] == value)//从mid位置向右找相同值
			{
				tempr++;
			}
			for (int i = templ + 1; i <= tempr - 1; i++)//把要查找的值的多个结果返回
			{
				list.add(i);
			}
			return list;
		}
	}
}

PS：要求有序序列

---

（3）插值查找

跟二分查找一样的原理，只有mid不一样；

mid = left + (right - left) * (value - arr[left]) / (arr[right] - arr[left]) （自适应）

import java.util.ArrayList;
import java.util.List;
public class Search 
{
	public static void main(String[] args) 
	{
		int [] arr = new int[] {2, 12, 21, 35, 35, 35, 57};//数组
		List<Integer> index = insertValSearch(arr, 0, arr.length - 1, 35);//插值查找
		if (index == null)
		{
			System.out.println("没有找到！");
		}
		else
		{
			System.out.println("找到，下标为" + index);
		}
	}
	/**
	 * 插值查找
	 * @param arr数组
	 * @param left左边的索引
	 * @param right右边的索引
	 * @param value要查找的值
	 * @return
	 */
	public static List<Integer> insertValSearch(int [] arr, int left, int right, int value)
	{
		if (left > right || value < arr[left] || value > arr[right])//必须，防越界
		{
			return null;
		}
		int mid = left + (right - left) * (value - arr[left]) / (arr[right] - arr[left]);
		if (value > arr[mid])//右递归
		{
			return insertValSearch(arr, mid + 1, right, value);
		}
		else if (value < arr[mid])//左递归
		{
			return insertValSearch(arr, left, mid - 1, value);
		}
		else
		{//处理多个相同值情况，如果不用直接写return mid即可
			List<Integer> list = new ArrayList<Integer>();
			int templ = mid - 1;
			while (templ >=0 && arr[templ] == value)//从mid位置向左找相同值
			{
				templ--;
			}
			int tempr = mid + 1;
			while (tempr < arr.length && arr[tempr] == value)//从mid位置向右找相同值
			{
				tempr++;
			}
			for (int i = templ + 1; i <= tempr - 1; i++)//把要查找的值的多个结果返回
			{
				list.add(i);
			}
			return list;
		}
	}
}

PS：要求有序数组

对于数据量较大，关键字分布均匀情况下使用插值查找方法速度快；

关键字分布不均匀（不连续，跳跃性较大）情况下，插值查找方法不一定比二分查找方法好

---

（4）斐波那契查找

与二分查找、插值查找原理的意思差不多，最特别的是斐波那契查找的mid是根据黄金分割法原理，斐波那契数列的两个相邻数的比例，无限接近黄金分割值；

mid = f[k - 1] - 1;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class Search 
{
	static int MaxSize = 20;
	public static void main(String[] args) 
	{
		int [] arr = new int[] {2, 12, 21, 35, 57, 80};//数组
		int index = fibSearch(arr, 2);//斐波那契查找
		if (index == -1)
		{
			System.out.println("没有找到！");
		}
		else
		{
			System.out.println("找到，下标为" + index);
		}
	}
	/**
	 * 斐波那契查找
	 * @param arr数组
	 * @param value要查找的值
	 * @return
	 */
	public static int fibSearch(int [] arr, int value)
	{
		int left = 0;//左索引
		int right = arr.length - 1;//右索引
		int [] f = fib();//斐波那契数列
		int mid = 0;//mid值
		int k = 0;//斐波那契数列分割数值的下标
		while (f[k] - 1 < right)//获取斐波那契数列分割数值的下标
		{
			k++;
		}
		int [] temp = Arrays.copyOf(arr, f[k]);//因为f[k]可能大于arr的长度
		int len = temp.length;
		for (int i = right + 1; i < len; i++)//用arr数组最后一个数填充大于arr数组长度的部分
		{
			temp[i] = arr[right];
		}
		while (left <= right)
		{
			mid = left + f[k - 1] - 1;//mid值
			if (value > temp[mid])//不满足，右边查找
			{
				left = mid + 1;
				k -= 2;
			}
			else if (value < temp[mid])//不满足，左边查找
			{
				right = mid - 1;
				k -= 1;
			}
			else
			{
				if (mid <= right)//处理当mid处于大于arr数组长度的部分，则返回arr数组最后的索引
				{
					return mid;
				}
				else
				{
					return right;
				}
			}
		}
		return -1;
	}
    /**
	 * 斐波那契数组
	 * @return斐波那契数组
	 */
	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;
	}
}

PS：要求有序数组

---