四种查找算法

二、查找

1.顺序查找

太简单，不用总结

2.二分查找

思想为取中间元素作为比较对象，若给定值与中间元素的关键字相等，则查找成功。若给定值小于中间元素关键字，则在在左半区继续查找，否则在右半区查找。不断重复，直到查找成功，或所查找的区域无元素，查找失败。

public static int binarySearch(int[] array, int value) {
    return search(array, 0, array.length-1, value);
}
private static int searchmy(int array[], int left, int right, int value) {
    if (left > right)
        return -1;
    int mid = left + (right-left)/2;
       
    if (value < array[mid]){
        return search(array, left, mid - 1, value);
    } else if {
        return search(array, mid + 1, right, value);
    }
    return mid;
}

时间效率为O（log2^n）

3.差值查找

差值查找是平均性能最好的查找方法，但只适合关键字均匀分布的表

public static int search(int[] arr,int left,int right,int value){
    if (left>= right || value>arr[arr.length-1] || value<arr[0]){
        return -1;
    }
​
    System.out.println("查找");
​
    int mid = left + (right-left) * (value - arr[left])/(arr[right] - arr[left]);
​
    if (arr[mid] == value){
        return mid;
    }else if (arr[mid]>value){
        return search(arr,left,mid-1,value);
    }else {
        return search(arr,left+1,right,value);
    }
}

其时间效率依然是O（log2^n）

4.斐波那契查找

斐波那契查找通过斐波那契数列对有序表进行分割，查找区间的两个端点和中点都与斐波那契数列有关。

public static int search(int[] array, int value) {
    int[] fibonacci = fibonacci(20);
    int i = 0;
    int left = 0, right = array.length - 1;
​
    while (fibonacci[i] < array.length) {
        i++;
    }
​
    int[] temp = Arrays.copyOf(array, fibonacci[i]);
    for (int j = array.length; j < temp.length; j++) {
        temp[j] = array[array.length - 1];
    }
​
    while (left <= right) {
        int mid = left + fibonacci[i - 1] - 1;
​
        if (temp[mid] > value) {
            right = mid - 1;
            i--;
        } else if (temp[mid] < value) {
            left = mid + 1;
            i -= 2;
        } else {
            return Math.min(mid, right);
        }
    }
​
    return -1;
}
​
public static int[] fibonacci(int n) {
    int[] fibonacci = new int[n];
​
    fibonacci[0] = 1;
    fibonacci[1] = 1;
​
    for (int i = 2; i < n; i++) {
        fibonacci[i] = fibonacci[i - 1] + fibonacci[i - 2];
    }
    return fibonacci;
}

当n很大时，该方法称为黄金分割法，其平均性能比折半查找好，但其时间效率仍为O（log2^n），而且在最坏情况下比折半查找法差。其优点是计算中点仅作加、减运算。