常见查找算法整理（Java实现）

1.顺序查找（Linear Search）

原理

        逐个遍历数组元素，直到找到目标值或遍历完整个数组。
        适用场景：无序或小规模数据。

代码

public static int linearSearch(int[] arr, int target) {
    for (int i = 0; i < arr.length; i++) {
        if (arr[i] == target) {
            return i; // 找到返回索引
        }
    }
    return -1; // 未找到
}

复杂度

• 时间：O(n)

• 空间：O(1)

2. 二分查找（Binary Search）

原理

        针对有序数组，每次比较中间元素，缩小一半搜索范围。
        适用场景：有序且静态数据（无频繁插入/删除）。

代码

public static int binarySearch(int[] arr, int target) {
    int left = 0, right = arr.length - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2; // 避免整数溢出
        if (arr[mid] == target) {
            return mid;
        } else if (arr[mid] < target) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    return -1;
}

复杂度

• 时间：O(log n)

• 空间：O(1)

 3.插值查找（Interpolation Search）

原理

        改进的二分查找，根据目标值在数组中的可能位置估算中间点。
        适用场景：数据分布均匀且有序的大规模数据。

代码

public static int interpolationSearch(int[] arr, int target) {
    int left = 0, right = arr.length - 1;
    while (left <= right && target >= arr[left] && target <= arr[right]) {
        // 计算插值位置公式
        int pos = left + (target - arr[left]) * (right - left) / (arr[right] - arr[left]);
        if (arr[pos] == target) {
            return pos;
        } else if (arr[pos] < target) {
            left = pos + 1;
        } else {
            right = pos - 1;
        }
    }
    return -1;
}

 复杂度

• 时间：平均 O(log log n)，最坏 O(n)（分布不均时）

• 空间：O(1)

4.哈希查找（Hash Table）

原理

        通过哈希函数将键映射到存储位置，直接访问目标值。
        适用场景：需要快速查找、插入和删除（如数据库索引）。 

代码

import java.util.HashMap;

public class HashSearch {
    public static void main(String[] args) {
        HashMap map = new HashMap<>();
        map.put(1, "Apple");
        map.put(2, "Banana");
        map.put(3, "Cherry");
        
        String value = map.get(2); // 查找键为2的值
        System.out.println(value); // 输出 "Banana"
    }
}

 复杂度

• 时间：平均 O(1)，最坏 O(n)（哈希冲突严重时）

• 空间：O(n)

 5. 二叉搜索树查找（Binary Search Tree, BST）

原理

        利用二叉搜索树的性质：左子树所有节点 < 根节点 < 右子树所有节点。
        适用场景：动态数据集（频繁插入/删除）。

代码

class TreeNode {
    int val;
    TreeNode left, right;
    TreeNode(int val) { this.val = val; }
}

public class BSTSearch {
    public static TreeNode search(TreeNode root, int target) {
        if (root == null || root.val == target) {
            return root;
        }
        if (target < root.val) {
            return search(root.left, target);
        } else {
            return search(root.right, target);
        }
    }
}

复杂度

• 时间：平均 O(log n)，最坏 O(n)（树退化为链表）

• 空间：平均 O(log n)（递归栈），最坏 O(n)

6.分块查找（Block Search）

原理

        将数组分为若干块，块内无序但块间有序。先定位块，再在块内顺序查找。
        适用场景：数据分块存储（如数据库分页）。 

代码

public static int blockSearch(int[] arr, int target, int blockSize) {
    int blockIndex = 0;
    // 定位块：假设块间按最大值有序
    while (blockIndex * blockSize < arr.length && 
           arr[Math.min((blockIndex+1)*blockSize -1, arr.length-1)] < target) {
        blockIndex++;
    }
    // 在块内顺序查找
    int start = blockIndex * blockSize;
    int end = Math.min(start + blockSize, arr.length);
    for (int i = start; i < end; i++) {
        if (arr[i] == target) return i;
    }
    return -1;
}

复杂度

• 时间：O(√n)（块数为√n时最优）

• 空间：O(1)

总结

查找算法	平均时间复杂度	空间复杂度	适用场景
顺序查找	O(n)	O(1)	小规模或无序数据
二分查找	O(log n)	O(1)	有序静态数据
插值查找	O(log log n)	O(1)	均匀分布的有序大数据
哈希查找	O(1)	O(n)	快速查询、插入、删除
二叉搜索树查找	O(log n)	O(n)	动态数据集
分块查找	O(√n)	O(1)	分块存储数据（如数据库）

• 数据无序且量小 → 顺序查找

• 数据有序且静态 → 二分查找或插值查找

• 频繁插入/删除 → 二叉搜索树（或更优的平衡树如AVL、红黑树）

• 极速查找 → 哈希表（需内存充足）