1.线性查找算法
有一个数列: {1,8, 10, 89, 1000, 1234} ,判断数列中是否包含此名称【顺序查找】 要求: 如果找到了,就提示找到,并给出下标值。
这个没什么好说的,逐一比对就好了,代码略
2.二分查找算法
请对一个有序数组进行二分查找 {1,8, 10, 89, 1000, 1234} ,输入一个数看看该数组是否存在此数,并且求出下标,如果没有就提示"没有这个数"。
二分查找的思路如下所示:
示例代码如下:
//二分查找算法
/**
*
* @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;
}
}
//完成一个课后思考题
/**
* 如果有多个相同的数值时,如何将所有的数值都查到,比如这里的1000
* 思路分析:
* 1、找到mid值后,不要马上返回,将所有的满足1000的元素的下标加入集合中
* 2、向右边扫描,将所有的满足1000的元素的下标加入到集合中
* 3、将ArrayList返回
* @return
*/
public static List<Integer> binarySearch2(int[] arr, int left, int right, int findVal){
List<Integer> resIndexList=new ArrayList<>();
if (left>right){
return null;
}
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{
//向左边扫描
int temp=mid-1;
while (true){
if (temp<0||arr[temp]!=findVal){
break;
}
//否则将temp放入集合中
resIndexList.add(temp);
temp-=1;
}
resIndexList.add(mid);
//向右边扫描
temp=mid+1;
while (true){
if (temp>arr.length-1||arr[temp]!=findVal){
break;
}
//否则就将temp放入到集合
resIndexList.add(temp);
temp+=1;
}
return resIndexList;
}
}
3.插值查找算法
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,8, 10, 89, 1000, 1234} ,输入一个数看看该数组是否存在此数,并且求出下标,如果没有就提示"没有这个数"。
代码如下:
//编写差值查找算法
/**
*
* @param arr:数组
* @param left:左边的索引
* @param right:右边的索引
* @param findVal:要查找的数值
* @return
*/
public static int insertValueSearch(int[] arr,int left,int right,int findVal){
//后面的两个值必须有,否则会越界
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;
}
}
插值查找注意事项:
1、对于数据量较大,关键字分布比较均匀的查找表来说,采用插值查找, 速度较快.
2、关键字分布不均匀的情况下,该方法不一定比折半查找要好
4.斐波那契(黄金分割法)查找算法
4.1斐波那契(黄金分割法)查找基本介绍
黄金分割点是指把一条线段分割为两部分,使其中一部分与全长之比等于另一部分与这部分之比。取其前三位数字的近似值是0.618。由于按此比例设计的造型十分美丽,因此称为黄金分割,也称为中外比。这是一个神奇的数字,会带来意向不大的效果。
斐波那契数列 {1, 1, 2, 3, 5, 8, 13, 21, 34, 55 } 发现斐波那契数列的两个相邻数 的比例,无限接近 黄金分割值0.618
4.2斐波那契(黄金分割法)查找算法原理
斐波那契查找原理与前两种相似,仅仅改变了中间结点(mid)的位置,mid不再是中间或插值得到,而是位于黄金分割点附近,即mid=low+F(k-1)-1(F代表斐波那契数列),如下图所示
对F(k-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
- 类似的,每一子段也可以用相同的方式分割,但顺序表长度n不一定刚好等于F[k]-1,所以需要将原来的顺序表长度n增加至F[k]-1。这里的k值只要能使得F[k]-1恰好大于或等于n即可,由以下代码得到,顺序表长度增加后,新增的位置(从n+1到F[k]-1位置),都赋为n位置的值即可。
示例代码如下:
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("index="+fibSearch(arr,1234));
}
//因为后面我们的公式 mid=F(k-1)-1,因此我们需要获取到斐波那契数列
//非递归方式得到
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;
}
//编写斐波拉锲查找算法
//使用非递归的方式编写算法
/**
*
* @param a 数组
* @param key 我们要查找的关键词
* @return 返回对应的下标
*/
public static int fibSearch(int[] a,int key){
int low=0;
int high=a.length-1;
int k=0;//表示斐波那契分割数值对应的下标
int mid=0;//存放mid值
int f[]=fib();//获取到斐波那契数列
//获取到斐波那契分割数值的下标
while (high>f[k]-1){
k++;
}
//因为f【k】可能大于数组的长度,因此我们需要使用Arrays类
//因此我们需要使用Arrays类,创建一个新的数组,并且指向a[]
int[] temp= Arrays.copyOf(a,f[k]);//不足的部分使用0填充
//实际上需要使用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--?
//1、全部元素=前面的元素+后面的元素
//2、f[k]=f[k-1]+f[k-2]
//因为前面有f[k-1]个元素,所以可以继续拆分f[k-1]=f[k-2]+f[k-3]
//即在f[k-1]前面继续查找k--
//下次循环就是mid=f[k-1-1]-1
k--;
}else if(key>temp[mid]){//右边查找
//为什么是k-=2?
//说明
//1、全部元素=前面的元素+后面的元素
//2、f[k]=f[k-1]+f[k-2]
//3、因为后面我们有f[k-2],可以继续拆分f[k-1]=f[k-3]+f[k-4]
//4、即是f[k-2]的前面进行查找k-=2
//5、即下次循环mid=f[k-1-2]-1
low=mid+1;
k-=2;
}else {
// //需要确定的是返回的是哪个下标
if (mid<=high){
return mid;
}else {
return high;
}
}
}
return -1;
}
}