数据结构-二分查找Java实现

一、引言

    二分查找，也被称为二分搜索或折半查找，是一种用于在有序数组或列表中查找特定元素的高效算法。其基本思想是将查找范围逐步缩小，直到找到目标元素或确定目标元素不存在。二分查找的时间复杂度为O(log n)，相对于线性查找的O(n)来说，效率非常高。

二、算法步骤

二分查找的基本步骤如下：

1. 准备工作： 二分查找要求目标数组必须是有序的，可以是升序或降序。通常，数组需要按升序排列。
2. 初始化边界： 初始化两个指针，一个指向数组的起始位置，另一个指向数组的结束位置。这些指针表示当前查找范围。
3. 查找中间元素： 计算中间元素的索引，通常通过 (左边界 + 右边界) / 2 来获得。这个中间元素用于与目标元素进行比较。
4. 比较中间元素： 将中间元素与目标元素进行比较。如果中间元素等于目标元素，查找成功，返回中间元素的索引。
5. 缩小查找范围： 如果中间元素大于目标元素，说明目标元素位于中间元素的左侧，此时将右边界指针移动到中间元素前一个位置。如果中间元素小于目标元素，说明目标元素位于中间元素的右侧，此时将左边界指针移动到中间元素后一个位置。
6. 重复过程： 重复步骤 3 和步骤 4 直到找到目标元素或确定目标元素不存在。如果左边界大于右边界，说明目标元素不在数组中，查找失败。

三、原理演示

假设我们有一个有序数组 arr，如下所示：
arr = [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
我们的目标是查找数字 12 是否在数组中，以及它的索引位置。
步骤1 - 初始化： 初始时，我们有两个指针，left 指向数组的起始位置，right 指向数组的结束位置。
left = 0
right = 9
步骤2 - 计算中间元素： 现在，我们计算中间元素的索引。 (left + right) / 2 为 (0 + 9) / 2，所以中间元素的索引为 4。
步骤3 - 比较中间元素： 我们将中间元素 arr[4] 与目标元素 12 进行比较。 arr[4] 是 10，这小于 12。因此，我们知道目标元素 12 应该在中间元素的右侧。
步骤4 - 重复过程： 现在，我们更新左右边界指针，以便缩小查找范围。由于目标元素在中间元素的右侧，我们将 left 更新为 mid + 1。
left = 5
right = 9
再次计算中间元素： 计算新的中间元素， (left + right) / 2 为 (5 + 9) / 2，中间元素的索引为 7。
再次比较中间元素： 我们将中间元素 arr[7] 与目标元素 12 进行比较。 arr[7] 是 16，这大于 12。因此，我们知道目标元素 12 应该在中间元素的左侧。
继续更新边界指针： 我们将 right 更新为 mid - 1。
left = 5
right = 6
再次计算中间元素： 计算新的中间元素， (left + right) / 2 为 (5 + 6) / 2，中间元素的索引为 5。
再次比较中间元素： 我们将中间元素 arr[5] 与目标元素 12 进行比较。 arr[5] 正好是目标元素 12。查找成功，我们找到了目标元素。

四、代码实战

以下是一个简单的二分查找代码示例:

public class BinarySearch {
   public static int binarySearch(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) {
               left = mid + 1; // 目标元素在右半部分
           } else {
               right = mid - 1; // 目标元素在左半部分
           }
       }

       return -1; // 目标元素不在数组中
   }

   public static void main(String[] args) {
       int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
       int target = 6;
       int result = binarySearch(arr, target);
       if (result != -1) {
          System.out.println("目标元素 " + target + " 在索引 " + result + " 处找到。");
       } else {
           System.out.println("目标元素 " + target + " 未找到。");
       }
   }
}

五、结论

我们一起来总结一下：

1. 时间复杂度：二分查找的时间复杂度为O(log n)，其中n是数组的元素数量。这使得二分查找在处理大规模数据时，效率优于许多其他搜索算法。
2. 适用场景：二分查找只适用于已排序的数组。这是因为在搜索过程中，我们需要确定目标元素在哪一半中，而这只能在已排序的数组中快速完成。
3. 实现：二分查找的实现非常简单，只需要确定目标元素在哪一半中，然后在那一半中继续搜索。每次循环，我们都将搜索范围减半。
4. 稳定性和空间复杂度：二分查找是稳定的算法，也就是说，它不会改变输入数组的顺序。此外，它的空间复杂度为O(1)，因为它不需要额外的存储空间。
5. 查找非排序数组：如果要在未排序的数组中查找元素，通常的做法是先对数组进行排序，然后使用二分查找。但是，你也可以使用其他搜索算法，如线性搜索。
6. 查找有序但非整数数组：二分查找只适用于整数数组，但如果要在其他类型的数组（如字符串或浮点数数组）中查找元素，可能需要使用其他搜索算法。
7. 最坏情况和最好情况：在最好的情况下（即目标元素位于数组的第一个或最后一个位置），二分查找只需要进行一次比较。在最坏的情况下（即目标元素位于数组的中间位置），二分查找需要进行n次比较。然而，由于平均情况下二分查找只需要进行log n次比较，因此它的平均性能仍然非常好。
8. 错误处理：如果数组中存在重复元素，二分查找可能会返回错误的结果。例如，在一个包含多个相同元素的数组中，二分查找可能会返回任何一个相同元素的索引，而不是目标元素的索引。为了解决这个问题，你可以在每次找到目标元素时检查其索引是否与前一个元素的索引不同。
9. 扩展应用：除了基本的二分查找之外，还可以扩展出许多其他的应用，例如找到一个数列的中位数、在一个数列中寻找一个数出现的最早的索引等。

点赞收藏，富婆包养✋✋