二分查找详解-CSDN博客

本文链接：https://blog.csdn.net/qq_41256535/article/details/139564688

二分查找（Binary Search）是一种在有序数组中查找某一特定元素的搜索算法。搜索过程从数组的中间元素开始，如果中间元素正好是要查找的元素，则搜索过程结束；如果某一特定元素大于或者小于中间元素，则在数组大于或小于中间元素的那一半中查找，而且跟开始一样从中间元素开始比较。如果在某一步骤数组为空，则代表找不到。这种搜索算法每一次比较都使搜索范围缩小一半。

二分查找的前提条件

数组必须是有序的（升序或降序）。
数组中的元素必须是唯一的，或者至少搜索目标在数组中只有一个匹配项。

二分查找的基本思想

假设数据是按升序排序的，对于给定的值x，从数组的中间元素开始，如果中间元素正好是要查找的元素，则搜索过程结束；如果某一特定元素大于或者小于中间元素，则在数组大于或小于中间元素的那一半中查找，而且跟开始一样从中间元素开始比较。如果在某一步骤数组为空，则代表找不到。

二分查找的步骤

设定查找范围的起始索引 low 和终止索引 high，初始时 low = 0，high = 数组长度 - 1。
进入循环，当 low <= high 时执行以下步骤：
- 计算中间索引 mid = (low + high) / 2（注意整数除法）。
- 如果 arr[mid] 等于目标值，则返回 mid（找到目标）。
- 如果 arr[mid] 大于目标值，则在左半部分继续查找，更新 high = mid - 1。
- 如果 arr[mid] 小于目标值，则在右半部分继续查找，更新 low = mid + 1。
如果循环结束仍未找到目标值，则返回 -1 或其他表示未找到的标志。

二分查找的Java代码实现

public class BinarySearch {

    // 二分查找函数
    public static int binarySearch(int[] arr, int target) {
        if (arr == null || arr.length == 0) {
            return -1; // 空数组或null数组，返回-1
        }
        
        int low = 0;
        int high = arr.length - 1;
        
        while (low <= high) {
            int mid = low + (high - low) / 2; // 防止low和high较大时相加溢出
            if (arr[mid] == target) {
                return mid; // 找到目标，返回索引
            } else if (arr[mid] > target) {
                high = mid - 1; // 在左半部分继续查找
            } else {
                low = mid + 1; // 在右半部分继续查找
            }
        }
        
        return -1; // 未找到目标，返回-1
    }
    
    // 测试二分查找函数
    public static void main(String[] args) {
        int[] arr = {2, 3, 4, 10, 40}; // 示例有序数组
        int target = 10; // 要查找的目标值
        int result = binarySearch(arr, target);
        if (result != -1) {
            System.out.println("找到目标值 " + target + "，索引为 " + result);
        } else {
            System.out.println("未找到目标值 " + target);
        }
    }
}

二分查找的时间复杂度和空间复杂度

时间复杂度：O(log n)。因为每次查找都将搜索范围缩小一半，所以时间复杂度是对数级别的。
空间复杂度：O(1)。二分查找只使用了常数个额外变量来存储索引，不随输入规模的变化而变化。

二分查找的变种与实际应用

1. 插值查找（Interpolation Search）

插值查找是基于二分查找的一种改进方法，其基本思想是当查找某个值时，根据要查找的值在数组中的分布概率，利用数学插值公式来预测要查找元素可能存在的位置，从而减少比较次数。

插值查找的Java代码实现如下：

public class InterpolationSearch {

    public static int interpolationSearch(int[] arr, int target) {
        if (arr == null || arr.length == 0) {
            return -1;
        }

        int low = 0;
        int high = arr.length - 1;

        while (low <= high && target >= arr[low] && target <= arr[high]) {
            // 插值公式
            int mid = low + ((high - low) * (target - arr[low]) / (arr[high] - arr[low]));

            if (arr[mid] == target) {
                return mid;
            }

            if (arr[mid] > target) {
                high = mid - 1;
            } else {
                low = mid + 1;
            }
        }

        return -1;
    }

    public static void main(String[] args) {
        int[] arr = {1, 3, 5, 7, 9, 11, 13, 15, 17, 19};
        int target = 13;
        int result = interpolationSearch(arr, target);

        if (result != -1) {
            System.out.println("找到目标值 " + target + "，索引为 " + result);
        } else {
            System.out.println("未找到目标值 " + target);
        }
    }
}

2. 二分查找树（Binary Search Tree）

二分查找树是一种特殊的二叉树，它的左子树上所有节点的值均小于它的根节点的值，右子树上所有节点的值均大于它的根节点的值。二分查找树在查找、插入和删除操作中，都保持了二分查找的特性，因此时间复杂度为O(log n)。

这里不直接给出BST的完整实现代码，因为它涉及较多内容，但以下是一个简单的BST节点类和一个插入方法的示例：

class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

    TreeNode(int x) {
        val = x;
    }
}

public class BinarySearchTree {

    TreeNode root;

    // 插入方法
    public void insert(int val) {
        root = insertRec(root, val);
    }

    private TreeNode insertRec(TreeNode root, int val) {
        if (root == null) {
            return new TreeNode(val);
        }

        if (val < root.val) {
            root.left = insertRec(root.left, val);
        } else if (val > root.val) {
            root.right = insertRec(root.right, val);
        }

        return root;
    }

    // 查找方法（此处略去）
    // ...
}