第七章 查找算法

7.1 顺序查找

算法思想

顺序查找，就是逐个遍历数组中的每一个元素，逐个比较它们和关键字是否相等，当查找到相等元素时， 遍历停止。当数组的规模逐渐扩大时候， 因为比较次数太多，顺序查找耗时太长。

算法实现

public class SqeSearchTest {

    public static void main(String[] args) {
        int[] array = {1, 9, 11, -1, 34, 89};
        int search = search(array, -1);
        System.err.println(search);
    }

    private static int search(int[] array, int value) {
        int index = -1;
        if (null == array || array.length == 0) {
            return index;
        }
        for (int i = 0; i < array.length; i++) {
            if (value == array[i]) {
                index = i;
                break;
            }
        }
        return index;
    }
}    

7.2 二分查找

算法思路

基于数组的有序性，每次都将当前的数组分为两半，通过关键字和中间元素的比较，立即排除掉其中不可能存在和键值相等的元素的那一半。这样每次减少的一半元素的比较，前后叠加起来，就是二分查找相对于顺序查找提高的性能。

算法描述

• 首先确定数组的中间下标 mid = (low + high) / 2
• 然后将需要查找的 key 和 array[mid] 进行比较。
• 如果 key > array[mid] 说明查找的 key 在 mid 的右边，因此需要向右递归查找。
• 如果 key < array[mid] 说明查找的 key 在 mid 的左边，因此需要向左递归查找。
• 如果 key == array[mid] 说明已经找到，结束递归。
• 如果 low > high 则结束递归。

算法实现

public class BinarySearchTest {

    public static void main(String[] args) {
        int[] array = new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9};
        System.err.println(Arrays.toString(array));
        List index = binarySearch(array, 0, array.length - 1, 3);
        System.err.println(index);
    }

    private static List binarySearch(int[] arrar, int left, int right, int value) {
        if (null == arrar || arrar.length == 0 || left > right) {
            return null;
        }
        int midIndex = (left + right) / 2;
        int midValue = arrar[midIndex];
        if (value > midValue) {
            return binarySearch(arrar, midIndex + 1, right, value);
        } else if (value < midValue) {
            return binarySearch(arrar, left, midIndex - 1, value);
        } else {
            /**
             * 1. 在找到 midIndex 索引值，不要马上返回
             * 2. 向 midIndex 索引值的左边扫描，将所有满足的元素的下标加入到集合 ArrayList
             * 3. 向 midIndex 索引值的右边扫描，将所有满足的元素的下标加入到集合 ArrayList
             * 4. 将 Arraylist 返回
             */
            List list = new ArrayList<>();
            list.add(midIndex);
            int temp = midIndex - 1;
            while (true) {
                if (temp < 0 || arrar[temp] != value) {
                    break;
                }
                list.add(temp--);
            }
            temp = midIndex + 1;
            while (true) {
                if (temp > arrar.length - 1 || arrar[temp] != value) {
                    break;
                }
                list.add(temp++);
            }
            return list;
        }
    }
}

7.3 插值查找

算法思路

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

算法描述

• 二分查找中求 mid 索引的公式，left 表示左边索引，right 表示右边索引：mid = (left + right) / 2 = left + 1/2 * (right - left)
• 插值查找中求自适应 mid 索引的公式：mid = low + (right - left) * (findVal – arr[left]) / (arr[right] – arr[left])
• 对于数据量较大且关键字分布比较均匀的查找表来说，采用插值查找速度较快，对于关键字分布不均匀的情况下，该方法不一定比二分查找要好。

算法实现

public class InsertValueSearchTest {

    public static void main(String[] args) {
        int[] array = new int[]{1, 8, 1000, 1000, 1000, 1000, 1234};
        System.err.println(Arrays.toString(array));
        List index = insertValueSearch(array, 0, array.length - 1, 1000);
        System.err.println(index);
    }

    private static List insertValueSearch(int[] arrar, int left, int right, int value) {
        if (null == arrar || arrar.length == 0 || left > right || value < arrar[0] || value > arrar[arrar.length - 1]) {
            return null;
        }
        // 插值
        int midIndex = left + (right - left) * (value - arrar[left]) / (arrar[right] - arrar[left]);
        int midValue = arrar[midIndex];
        if (value > midValue) {
            return insertValueSearch(arrar, midIndex + 1, right, value);
        } else if (value < midValue) {
            return insertValueSearch(arrar, left, midIndex - 1, value);
        } else {
            List list = new ArrayList<>();
            list.add(midIndex);
            int temp = midIndex - 1;
            while (true) {
                if (temp < 0 || arrar[temp] != value) {
                    break;
                }
                list.add(temp--);
            }
            temp = midIndex + 1;
            while (true) {
                if (temp > arrar.length - 1 || arrar[temp] != value) {
                    break;
                }
                list.add(temp++);
            }
            return list;
        }
    }
}

7.4 斐波那契查找

黄金分割点是指把一条线段分割为两部分，使其中一部分与全长之比等于另一部分与这部分之比。取其前三位
数字的近似值是 0.618，由于按此比例设计的造型十分美丽，因此称为黄金分割，也称为中外比。

斐波那契数列 {1, 1, 2, 3, 5, 8, 13, 21, 34, 55 } 发现数列的两个相邻数的比例无限接近黄金分割值0.618。

算法思路

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

算法描述

• 由于斐波那契数列具有 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
• 顺序数组长度 length 不一定刚好等于 F[k] - 1，所以需要将原来的顺序表长度 length 增加至 F[k] - 1，这里的 k 值只要能使得 F[k] - 1 恰好大于或等于 length 即可，新增的位置(从 n+1 到 F[k] - 1 位置)都赋为 length - 1 位置的值即可。

算法实现

public class FibonacciSearchTest {

    public static void main(String[] args) {
        int[] array = new int[]{1, 8, 98, 105, 1000, 1070, 1234};
        System.err.println(Arrays.toString(array));
        int search = fibSearch(array, 1000);
        System.err.println(search);
    }

    private static int fibSearch(int[] array, int value) {
        int low = 0;
        // 数组最大下标
        int high = array.length - 1;
        // 表示斐波那契分割数值的下标
        int k = 0;
        // 获取到斐波那契数列
        int fibArray[] = fibArray(20);
        // 找到有序表元素个数在斐波那契数列中最接近的最大数列值
        while (high > fibArray[k] - 1) {
            k++;
        }
        // 补齐有序表并指向 temp[]，不足的部分会使用 0 填充
        int[] temp = Arrays.copyOf(array, fibArray[k]);
        for (int i = high + 1; i < temp.length; i++) {
            temp[i] = array[high];
        }
        // 使用 while 来循环找到 key，需要满足条件 low <= high
        while (low <= high) {
            int mid = low + fibArray[k - 1] - 1;
            // 继续向数组的前面查找（左边）
            if (value < temp[mid]) {
                high = mid - 1;
                // 因为前面有 f[k-1] 个元素，所以可以继续拆分 f[k-1] = f[k-2] + f[k-3]
                k--;
            } else if (value > temp[mid]) {
                // 继续向数组的后面查找（右边）
                low = mid + 1;
                // 因为后面有 f[k-2] 个元素，所以可以继续拆分 f[k-2] = f[k-3] + f[k-4]，即下次循环 mid = f[k - 1 - 2] - 1
                k -= 2;
            } else {
                if (mid <= high) {
                    return mid;
                } else {
                    return high;
                }
            }
        }
        return -1;
    }

    private static int[] fibArray(int maxSize) {
        int[] array = new int[maxSize];
        array[0] = 1;
        array[1] = 1;
        for (int i = 2; i < maxSize; i++) {
            array[i] = array[i - 1] + array[i - 2];
        }
        return array;
    }
}