JAVA数据结构----查找算法

顺序查找

按照数组的顺序进行查找

package bilibili.search;

public class SeqSearch {
    public static void main(String[] args) {
        int[] array = {1,3,23,45,67,-6,12};
        int index = Search(array,45);
        System.out.println("下标为: " + index);
    }
    public static int Search(int[] array,int values){
        for (int i = 0; i < array.length; i++) {
            if(array[i]==values){
                return i;
            }
        }
        return -1;
    }
}

二分查找

二分查找的思路分析

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

什么时候我们需要结束递归.
(1) 找到就结束递归
(2) 递归完整个数组，仍然没有找到findVal ，也需要结束递归 当 left > right 就需要退出

package bilibili.search;

import java.util.*;

public class BinarySearch {
    public static void main(String[] args) {
        int[] array = {12, 23, 34, 56, 56, 56, 78, 98};
        int index = binarySearch(array, 0, array.length - 1, 56);
        System.out.println("下标为 :" + index);
        List<Integer> resList = binarySearch2(array, 0, array.length - 1, 56);
        System.out.println("下标为： " + resList);
    }

    //二分查找要求数组是有序的
    public static int binarySearch(int[] array, int left, int right, int findValue) {
        if (left > right) {
            return -1;
        }
        int mid = (left + right) / 2;
        int value = array[mid];
        if (findValue > value) {
            //向右进行递归
            return binarySearch(array, mid + 1, right, findValue);
        } else if (findValue < value) {
            //向左进行递归
            return binarySearch(array, left, mid - 1, findValue);
        } else {
            return mid;
        }
    }


    //将二分查找进行改进，可以找到同一个数组中的多个同一个数
    /*
    1. 在找到 mid 索引值，不要马上返回
     2. 向 mid 索引值的左边扫描，将所有满足 1000， 的元素的下标，加入到集合 ArrayList
     3. 向 mid 索引值的右边扫描，将所有满足 1000， 的元素的下标，加入到集合 ArrayList
      4. 将 Arraylist 返回
     */
    public static List<Integer> binarySearch2(int[] array, int left, int right, int findValue) {
        if (left > right) {
            return new ArrayList<Integer>();
        }

        int mid = (left + right) / 2;
        int value = array[mid];
        if (findValue > value) {
            //向右进行递归
            return binarySearch2(array, mid + 1, right, findValue);
        } else if (findValue < value) {
            //向左进行递归
            return binarySearch2(array, left, mid - 1, findValue);
        } else {
            List<Integer> resIndexlist = new ArrayList<Integer>();
            int tmp = mid - 1;
            while (true) {
                if (tmp < 0 || array[tmp] != findValue) {
                    break;
                }
                resIndexlist.add(tmp);
                tmp--;
            }
            resIndexlist.add(mid);
            int tmp2 = mid + 1;
            while (true) {
                if (tmp > right || array[tmp2] != findValue) {
                    break;
                }
                resIndexlist.add(tmp2);
                tmp2++;
            }
            return resIndexlist;
        }
    }
}

插值查找

插值查找算法类似于二分查找，不同的是插值查找每次从自适应 mid 处开始查找。插值查找也要求数组是有序的。

package bilibili.search;

public class InsertSearch {
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5,6,8,14,25,35};
        int index = insertSearch(array,0, array.length-1,6);
        System.out.println("下标为： " + index);
    }
    public static int insertSearch(int[] arr,int left,int right,int findVal){
        if(left>right||findVal<arr[0]||findVal>arr[arr.length-1]){
            //此处要有后两个条件的原因，如果要找的值很大或者很小，mid会受影响
            //从而影响数组赋值
            return -1;
        }
        int mid = left + (findVal-arr[left])/(arr[right]-arr[left])*(right-left);
        int tmp = arr[mid];
        if(findVal>tmp){
            return insertSearch(arr,mid+1,right,findVal);
        }else if(findVal<tmp){
            return insertSearch(arr,left,mid-1,findVal);
        }else {
            return mid;
        }
    }

}

插值查找注意事项：
(1) 对于数据量较大，关键字分布比较均匀的查找表来说，采用插值查找, 速度较快.

( 2) 关键字分布不均匀的情况下，该方法不一定比折半查找要好

斐波那契查找

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

(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 位置的值即可。
while(n>fib(k)-1)
k++;

package bilibili.search;
import java.util.Arrays;
public class FibSearch {
    public static void main(String[] args) {
        int[] array = {12, 23, 34, 56, 67, 78, 89};
        int index = fibSearch(array, 56);
        System.out.println("下标为： " + index);
    }
    //先构造一个斐波那契数列
    public static int[] fib() {
        int maxSize = 20;
        int[] fib = new int[maxSize];
        fib[0] = 1;
        fib[1] = 1;
        for (int i = 2; i < maxSize; i++) {
            fib[i] = fib[i - 1] + fib[i - 2];
        }
        return fib;
    }
    //斐波那契查找
    public static int fibSearch(int[] array, int findVal) {
        int right = array.length - 1;
        int left = 0;
        int k = 0;//k表示斐波那契数列的下标
        int[] f = fib();
        while (array.length > f[k] - 1) {
            k++;
        }
        //此时f[k]-1可能大于数组的长度
        int[] tmp = Arrays.copyOf(array, f[k] - 1);
        for (int i = right + 1; i < f[k] - 1; i++) {
            tmp[i] = array[right];
        }
        while (left <= right) {
            int mid = f[k - 1] - 1 + left;
            if (findVal < tmp[mid]) {
                right = mid - 1;
                k = k - 1;
            } else if (findVal > tmp[mid]) {
                left = mid + 1;
                k = k - 2;
            } else {
                if (mid < right) {
                    return mid;
                } else {
                    return right;
                }

            }
        }
        return -1;
    }
}