七大查找算法

查找算法

1. 顺序查找算法（Sequential Search Algorithm）：是一种简单的查找算法，它从第一个元素开始依次比较，直到找到要查找的元素，或者搜索到最后一个元素。适用于数据量较小的列表，时间复杂度为 O(n)。

2. 二分查找算法（Binary Search Algorithm）：也称作折半查找，它是一种在有序序列中查找特定元素的算法。适用于有序列表，时间复杂度为 O(log n)。

3. 插值查找算法（Interpolation Search Algorithm）：在二分查找的基础上优化了查找位置的方法，它根据查找关键字与查找区间的最大值和最小值进行比较，可以更快地找到指定元素。适用于数据均匀分布的有序列表，时间复杂度为 O(log log n)。

4. 斐波那契查找算法（Fibonacci Search Algorithm）：利用黄金分割原理，通过斐波那契数列中的数值确定查找点位置，也是一种针对有序序列的查找算法。适用于有序列表，时间复杂度为 O(log n)。

5. 树表查找算法（Tree Table Search Algorithm）：基于树型数据结构的查找算法，可以快速定位特定元素，常用的树表包括二叉查找树、AVL树、红黑树等。适用于大规模的动态查找表，时间复杂度为 O(log n)。

6. 分块查找算法（Block Search Algorithm）：将数据分成若干块，每块中的元素可以无序，但不同块之间必须按照某种顺序排序，该算法通过索引表进行查找，常用于静态查找。适用于数据分块但内部无序的列表，时间复杂度为 O(sqrt(n))。

7. 哈希表查找算法（Hash Table Search Algorithm）：将数据按照哈希函数散列到各个存储位置，通过关键字快速定位目标元素。由于哈希函数有可能出现哈希冲突，因此需要解决冲突问题，常用的解决方法包括链式法和开放寻址法。适用于大规模的静态查找表，时间复杂度为 O(1)。

顺序查找

工作原理是从一个给定的数据集合中，逐一检查每个元素，直到找到给定值或者确定没有给定值存在。它的步骤如下：从第一个元素开始，将它与要查找的值进行比较；如果相等，则查找结束；如果不相等，则继续查找；继续比较下一个元素，重复步骤2和3如果查找到最后一个元素仍然不相等，则结束查找，表明该值不存在。

    public static int sequentialSearch(int[] array, int target) {
        for (int i = 0; i < array.length; i++) {
            if (array[i] == target) {
                return i;
            }
        }
        return -1;
    }

二分查找

它的操作步骤如下：首先，从有序数组的中间位置开始搜索，如果该元素正好是要查找的元素，则搜索过程结束；如果某一特定元素大于要查找的元素，则在数组中间元素的左侧继续进行搜索；反之，如果某一特定元素小于要查找的元素，则在数组中间元素的右侧继续进行搜索。重复以上过程，直到找到要查找的元素，或者查找范围为空。

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

插值查找

插值查找是一种二分查找的变体，其核心是根据查询元素与数组中间元素的比较结果来调整查找范围，以加快查询速度。它的核心思想是：当搜索到一个关键字时，将搜索范围缩小一半，这样比较次数就会减少。它的查找公式为：middle=low+(key-a[low])/(a[high]-a[low])*(high-low)

    public static int interpolationSearch(int[] array, int target) {
        int low = 0;
        int high = array.length - 1;
        int mid;
        while (low <= high) {
            mid = low + (high - low) * (target - array[low]) / (array[high] - array[low]);
            if (array[mid] == target) {
                return mid;
            }
            if (array[mid] > target) {
                high = mid - 1;
            } else {
                low = mid + 1;
            }
        }
        return -1;
    }

斐波那契查找

斐波那契查找是一种特殊的二分查找，它根据斐波那契序列的特点对有序数组进行分割来查找指定值。通过切割数组的大小来减少搜索时间，它是一种非常高效的查找算法，其时间复杂度在最坏情况下为O(log n)。

    public static int fibonacciSearch(int[] arr, int key) {
        int low = 0;
        int high = arr.length - 1;
        int k = 0;
        int mid = 0;
        int f[] = fibonacci();
        while (high > f[k] - 1) {
            k++;
        }
        int[] temp = Arrays.copyOf(arr, f[k]);
        for (int i = high + 1; i < temp.length; i++) {
            temp[i] = arr[high];
        }
        while (low <= high) {
            mid = low + f[k - 1] - 1;
            if (key < temp[mid]) {
                high = mid - 1;
                k--;
            } else if (key > temp[mid]) {
                low = mid + 1;
                k -= 2;
            } else {
                if (mid <= high) {
                    return mid;
                } else {
                    return high;
                }
            }
        }
        return -1;
    }

    public static int[] fibonacci() {
        int[] f = new int[20];
        f[0] = 1;
        f[1] = 1;
        for (int i = 2; i < 20; i++) {
            f[i] = f[i - 1] + f[i - 2];
        }
        return f;
    }

二叉树查找

二叉树查找是一种在二叉搜索树中查找特定键值的搜索算法。在二叉搜索树中，查找过程从根节点开始，如果查找的键值小于根节点的键值，则将查找范围缩小到根节点的左子树，反之则在右子树中查找，直到找到相应的键值或找不到为止。

/* 二叉树节点 */
class Node {
    int key;
    Node left, right;

    public Node(int item) {
        key = item;
        left = right = null;
    }
}

/* 二叉查找树类 */
class BinarySearchTree {
    Node root;

    /* 构造方法 */
    BinarySearchTree() {
        root = null;
    }

    /* 查找 */
    public Node search(Node root, int key) {
        // 如果根为 null 或者根等于 key，则返回根
        if (root == null || root.key == key)
            return root;

        // 如果根的 key 大于给定的 key，则在左子树中查找
        if (root.key > key)
            return search(root.left, key);

        // 如果根的 key 小于给定的 key，则在右子树中查找
        return search(root.right, key);
    }

    /* 插入 */
    public void insert(int key) {
        root = insertRec(root, key);
    }

    /* 插入递归函数 */
    Node insertRec(Node root, int key) {
        /* 如果根为空，则创建一个新节点 */
        if (root == null) {
            root = new Node(key);
            return root;
        }

        /* 如果 key 小于根的 key，则在左子树中插入 */
        if (key < root.key)
            root.left = insertRec(root.left, key);

        /* 如果 key 大于根的 key，则在右子树中插入 */
        else if (key > root.key)
            root.right = insertRec(root.right, key);

        /* 返回新树 */
        return root;
    }

    /* 中序遍历 */
    public void inorder() {
        inorderRec(root);
    }

    /* 中序遍历递归函数 */
    void inorderRec(Node root) {
        if (root != null) {
            inorderRec(root.left);
            System.out.print(root.key + " ");
            inorderRec(root.right);
        }
    }

    /* 测试程序 */
    public static void main(String[] args) {
        BinarySearchTree tree = new BinarySearchTree();

        /* 插入节点 */
        tree.insert(50);
        tree.insert(30);
        tree.insert(20);
        tree.insert(40);
        tree.insert(70);
        tree.insert(60);
        tree.insert(80);

        /* 搜索节点 */
        Node foundNode = tree.search(tree.root, 60);
        if (foundNode != null)
            System.out.println("找到了节点 " + foundNode.key);
        else
            System.out.println("未找到节点");

        /* 中序遍历 */
        tree.inorder();
    }
}

分块查找

分块查找是一种查找算法，它是一种分而治之的思想，将一个大的数据序列划分成多个小的块，然后在每一个块中进行查找，查询时间就可以大大缩短。

//其中函数 `search` 接受一个整数数组 `arr`、块大小 `blockSize` 和要查找的值 `value`，返回 `value` 在 `arr` 中的位置，如果没有找到，返回 -1。
//该函数首先将数组分成若干块，记录每个块的最大值，然后在块中使用二分查找查找 `value`。
public class BlockSearch {
    
    public static int search(int[] arr, int blockSize, int value) {
        int n = arr.length;
        int numBlocks = (int) Math.ceil(n / (double) blockSize);
        int[] blockMax = new int[numBlocks];
        
        // 分块，记录每个块的最大值
        for (int i = 0; i < numBlocks; i++) {
            int max = Integer.MIN_VALUE;
            for (int j = i * blockSize; j < Math.min(n, (i + 1) * blockSize); j++) {
                max = Math.max(max, arr[j]);
            }
            blockMax[i] = max;
        }
        
        // 在块中二分查找
        for (int i = 0; i < numBlocks; i++) {
            if (value <= blockMax[i]) {
                for (int j = i * blockSize; j < Math.min(n, (i + 1) * blockSize); j++) {
                    if (arr[j] == value) {
                        return j;
                    }
                }
                break;
            }
        }
        
        return -1; // 没有找到
    }
    
    public static void main(String[] args) {
        int[] arr = {2, 4, 6, 8, 1, 3, 5, 7, 9};
        int blockSize = 3;
        int value = 5;
        int index = search(arr, blockSize, value);
        if (index != -1) {
            System.out.println(value + " 在数组中的位置是 " + index);
        } else {
            System.out.println("没有找到 " + value);
        }
    }
}

哈希查找

哈希查找是一种速度比较快的查找算法，它使用一种叫哈希函数的函数将数据映射到一个关键字上，以便更快地查找数据。哈希查找的运行时间只与数据的个数有关，而与数据的规模无关，所以它的运行速度是固定的，不会随着数据的增加而减慢。

//我们定义了一个静态数组 `array`，然后实现了一个 `hashSearch` 方法，该方法接受一个关键字 `key`，并使用哈希函数 `key % SIZE` 将该关键字映射为一个索引。
//如果对应的数组元素等于关键字，则返回该元素的索引；否则，向后查找直到找到一个空元素或找遍了整个哈希表为止。如果仍然没有找到，则返回 -1 表示关键字不在数组中。
public static int hashSearch(int[] array, int key) {
        int size = array.size();
        int hash = key % size;
        while (array[hash] != 0) {
            if (array[hash] == key) {
                return hash;
            }
            hash = (hash + 1) % size;
        }
        return -1;
    }

相关参考

https://www.cnblogs.com/maybe2030/p/4715035.html