java实现查找算法（顺序查找、二分查找、插值查找、斐波那契查找）

public int seqSearch(int[] a, int n) {
    for (int i = 0; i < a.length; i++) {
        if (a[i] == n) {
            return i;
        }
    }
    return -1;
}

public static int binarySearch(int[] a, int left, int right, int n) {
    if (left > right) {
        return -1;
    }
    int mid = (left + right) / 2;
    if (a[mid] == n) {
        return mid;
    } else if (a[mid] > n) {
        return binarySearch(a, left, mid - 1, n);
    } else {
        return binarySearch(a, mid + 1, right, n);
    }
}


// 找到数组中包含的所有被查找值
public static List binarySearchAll(int[] a, int left, int right, int n) {
    List res = new ArrayList<>();
    if (left > right) {
        return res;
    }
    int mid = (left + right) / 2;
    int tmp = mid - 1;
    if (a[mid] == n) {
        while (tmp >= 0 && a[tmp] == n) {
            res.add(tmp);
            tmp--;
        }
        res.add(mid);
        tmp = mid + 1;
        while (tmp <= a.length - 1 && a[tmp] == n) {
            res.add(tmp);
            tmp++;
        }
        return res;
    } else if (a[mid] > n) {
        return binarySearchAll(a, left, mid - 1, n);
    } else {
        return binarySearchAll(a, mid + 1, right, n);
    }
}

原理介绍：

（1）插值查找类似于二分查找，不同的是插值查找每次从自适应mid处开始查找。

（2）将二分查找中计算mid索引的公式做如下修改(key 为需要查找的值)：

public static int insertValueSearch(int[] a, int left, int right, int key) {
    if (left > right || key < a[0] || key > a[a.length - 1]) {
        return -1;
    }
    int mid = left + (right -left) * (key - a[left]) / (a[right] - a[left]);
    if (a[mid] == key) {
        return mid;
    } else if (a[mid] > key) {
        return insertValueSearch(a, left, mid - 1, key);
    } else {
        return insertValueSearch(a, mid + 1, right, key);
    }
}

适用于数据量大，关键字分布比较均匀的查找表。 

原理介绍：

        将mid的计算改变为：mid = left + F(k-1) -1。（F代表斐波那契数列）

对F(k-1) -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 = left + F(k - 1) - 1。

（2）顺序表长度不一定刚好等于F(k) - 1，所以需要将原来的顺序表长度n增加至F(k) -1。此处k只要使得F(k) - 1恰好大于或等于n即可。

public class FibonacciSearch {
    public static int maxSize = 20;

    // 因为计算max = 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;
    }

    
    public static int fibonacciSearch(int[] a, int key) {
        int left = 0;
        int right = a.length - 1;
        int k = 0; // 表示斐波那契分割数值的下标
        int mid = 0;
        int[] f = fib();

        // 获取斐波那契分割数值的下标k
        while (right > f[k] - 1) {
            k++;
        }

        // 因为f(k)值可能大于a的长度，因此我们需要使用Arrays类构造一个新的数组，并指向tmp []
        int[] tmp = Arrays.copyOf(a, f[k]);

        // 使用a数组最后的数填充tmp
        for (int i = right + 1; i < tmp.length; i++) {
            tmp[i] = a[right];
        }

        while (left <= right) {
            mid = left + f[k - 1] - 1;
            if (key < tmp[mid]) {
                right = mid - 1;

                // f[k] = f[k - 1] + f[k - 2], f[k - 1] = f[k - 2] + f[k - 3]
                // 因此在f[k - 1]的前面继续查找 k--, 即下次循环mid = f[k - 1 - 1] -1
                k--;
            } else if (key > tmp[mid]) {
                left = mid + 1;

                // f[k] = f[k - 1] + f[k - 2], 因为后面有f[k-2], 所以继续拆分f[k - 2] = f[k - 3] + f[k - 4]
                // 即在f[k-2]前面进行查找k-=2,即下次循环 mid = f[k-1-2] -1
                k -= 2;
            } else {
                return Math.min(mid, right);
            }
        }
        return -1;
    }

}