查找算法（二）：二分查找-CSDN博客

二分查找（Binary Search）是一种非常经典且高效的查找算法，广泛应用于有序数组或列表中，能够在对数时间内查找目标元素。相比于线性查找的 O(n) 时间复杂度，二分查找的时间复杂度为 O(log n)，因此它在大数据量下的查找效率显著提高。本文将深入讲解二分查找的原理、实现方法、优化策略，并通过 Java 代码进行详细的示范。

一、二分查找算法原理

二分查找算法基于有序数组的特点，通过反复将搜索区间一分为二来缩小查找范围。它的基本思想是：

初始条件：假设数组已经是有序的（升序或降序均可）。
查找过程：
- 比较中间元素与目标元素。
- 如果目标元素等于中间元素，查找成功。
- 如果目标元素小于中间元素，则目标在左半部分。
- 如果目标元素大于中间元素，则目标在右半部分。
结束条件：查找区间为空，表示目标元素不在数组中。

二分查找的时间复杂度

时间复杂度：每次查找都会将区间减半，因此时间复杂度为 O(log n)。
空间复杂度：如果使用递归实现，则空间复杂度为 O(log n)；如果使用迭代实现，则空间复杂度为 O(1)。

二、二分查找的实现

接下来，通过 Java 代码演示二分查找的两种常见实现方式：递归和迭代。

1. 递归实现

public class BinarySearch {
    
    // 递归版二分查找
    public static int binarySearchRecursive(int[] arr, int target, int left, int right) {
        // 递归结束条件：找不到
        if (left > right) {
            return -1;
        }
        
        int mid = left + (right - left) / 2;
        
        // 找到目标元素
        if (arr[mid] == target) {
            return mid;
        }
        
        // 目标小于中间值，递归左半部分
        if (arr[mid] > target) {
            return binarySearchRecursive(arr, target, left, mid - 1);
        }
        
        // 目标大于中间值，递归右半部分
        return binarySearchRecursive(arr, target, mid + 1, right);
    }

    public static void main(String[] args) {
        int[] arr = {1, 3, 5, 7, 9, 11, 13};
        int target = 7;
        int result = binarySearchRecursive(arr, target, 0, arr.length - 1);
        System.out.println("Element found at index: " + result);
    }
}

2. 迭代实现

public class BinarySearch {
    
    // 迭代版二分查找
    public static int binarySearchIterative(int[] arr, int target) {
        int left = 0;
        int right = arr.length - 1;
        
        while (left <= right) {
            int mid = left + (right - left) / 2;
            
            // 找到目标元素
            if (arr[mid] == target) {
                return mid;
            }
            
            // 目标小于中间值，调整右边界
            if (arr[mid] > target) {
                right = mid - 1;
            }
            
            // 目标大于中间值，调整左边界
            else {
                left = mid + 1;
            }
        }
        
        return -1;  // 目标元素不存在
    }

    public static void main(String[] args) {
        int[] arr = {1, 3, 5, 7, 9, 11, 13};
        int target = 7;
        int result = binarySearchIterative(arr, target);
        System.out.println("Element found at index: " + result);
    }
}

3. 代码对比

方面	递归实现	迭代实现
实现方式	使用递归函数调用进行查找	使用 `while` 循环进行查找
代码简洁度	较为简洁，易于理解	稍显冗长，但逻辑更加直观清晰
性能	每次递归调用会消耗栈空间，可能会导致栈溢出	不会产生递归调用，空间开销较小
可读性	递归更符合二分查找的思想	迭代更符合程序员的习惯

4. 边界情况处理

在实际应用中，我们需要注意几个常见的边界情况：

目标元素不存在：需要在查找结束后返回 -1，表示未找到。
数组为空：如果数组为空，直接返回 -1。
目标元素在数组的首尾：二分查找应该能够正确处理目标位于数组边缘的情况。

三、二分查找的变种

1. 查找最左边的元素

如果要求查找目标元素在数组中第一次出现的位置，可以进行如下修改：

public static int binarySearchFirst(int[] arr, int target) {
    int left = 0;
    int right = arr.length - 1;
    int result = -1;
    
    while (left <= right) {
        int mid = left + (right - left) / 2;
        
        if (arr[mid] == target) {
            result = mid;  // 记录当前位置
            right = mid - 1;  // 继续查找左半部分
        } else if (arr[mid] > target) {
            right = mid - 1;
        } else {
            left = mid + 1;
        }
    }
    
    return result;
}

2. 查找最右边的元素

同理，查找最后一个目标元素的索引：

public static int binarySearchLast(int[] arr, int target) {
    int left = 0;
    int right = arr.length - 1;
    int result = -1;
    
    while (left <= right) {
        int mid = left + (right - left) / 2;
        
        if (arr[mid] == target) {
            result = mid;  // 记录当前位置
            left = mid + 1;  // 继续查找右半部分
        } else if (arr[mid] > target) {
            right = mid - 1;
        } else {
            left = mid + 1;
        }
    }
    
    return result;
}

3. 查找插入位置

有时我们不仅需要找到目标元素，还需要知道插入目标元素的位置。可以使用二分查找来实现这一功能：

public static int binarySearchInsertPosition(int[] arr, int target) {
    int left = 0;
    int right = arr.length;
    
    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;
        }
    }
    
    return left;  // 返回插入位置
}