Java写二分查找

以下是Java实现二分查找的代码：

public static int binarySearch(int[] arr, int target) {
    int left = 0;
    int right = arr.length - 1;

    while (left <= right) {
        int mid = (left + right) / 2;

        if (arr[mid] == target) {
            return mid;
        } else if (arr[mid] < target) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }

    return -1;
}

该方法接收一个已排序的整数数组和一个目标值，返回目标值在数组中的索引（如果存在），否则返回-1。

二分查找的核心思想是通过比较目标值和数组中间元素的大小关系，缩小搜索范围。具体地，每次将搜索范围缩小一半，直到找到目标值或搜索范围为空。

相关问题

java 手写二分查找

二分查找（Binary Search）是一种常用的查找算法，它要求被查找的数组必须是有序的。下面是Java中手写二分查找的示例代码：

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;
            } else if (arr[mid] < target) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }

        return -1; // 如果未找到目标元素，则返回-1
    }

    public static void main(String[] args) {
        int[] arr = {1, 3, 5, 7, 9};
        int target = 5;
        int result = binarySearch(arr, target);
        System.out.println("目标元素的索引为：" + result);
    }
}

在上述代码中，`binarySearch`方法接收一个有序数组`arr`和目标元素`target`作为参数，使用循环实现二分查找。首先，初始化左边界`left`为数组的第一个元素的索引，右边界`right`为数组的最后一个元素的索引。然后，在每次循环中，计算中间元素的索引`mid`，并与目标元素进行比较。如果中间元素等于目标元素，则返回中间元素的索引；如果中间元素小于目标元素，则将左边界`left`更新为`mid + 1`；如果中间元素大于目标元素，则将右边界`right`更新为`mid - 1`。循环继续直到找到目标元素或者左边界大于右边界，此时表示未找到目标元素，返回-1。

用java写二分查找

### 回答1：
二分查找是一种在有序数组中查找特定元素的搜索算法。它的基本思想是将数组分成两个部分，每次比较中间元素的值和目标值的大小，并根据结果将搜索区间缩小一半。

下面是用 Java 实现二分查找的代码示例：

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

  public static void main(String[] args) {
    int[] array = {1, 3, 5, 7, 9};
    int target = 3;
    int result = binarySearch(array, target);
    if (result != -1) {
      System.out.println("Target found at index: " + result);
    } else {
      System.out.println("Target not found");
    }
  }
}

在这段代码中，我们定义了一个名为 `binarySearch` 的函数，它接受两个参数：一个数组和一个目标值。函数通过使用二分查找算法在数组中查找目标值，并返回目标值在数组中的位置（如果找到的话）。否则，函数返回 -1。

在 `main` 函数中，我们测试了这个函数，并在数组 `{1, 3, 5, 7, 9}` 中查找目标值 3。如果找到了，就会输出 "Target found at index: 1"（因为 3 在数组中

### 回答2：
二分查找（Binary Search）是一种常用的查找算法，它适用于有序的数组。通过将待查找的元素与数组中间元素进行比较，判断待查找元素在数组的左边还是右边，从而缩小查找范围，直到找到目标元素或范围为空为止。

以下是使用Java语言编写二分查找的示例代码：

public class BinarySearch {
    // 二分查找方法
    public static int binarySearch(int[] array, int target) {
        int left = 0;
        int right = array.length - 1;

        while (left <= right) {
            int mid = (left + right) / 2;

            if (array[mid] == target) {
                return mid;  // 找到目标元素，返回索引
            }

            if (array[mid] < target) {
                left = mid + 1;  // 目标元素在右半部分，更新左边界
            } else {
                right = mid - 1;  // 目标元素在左半部分，更新右边界
            }
        }

        return -1;  // 没有找到目标元素，返回-1
    }

    public static void main(String[] args) {
        int[] array = {1, 3, 5, 7, 9, 11, 13};
        int target = 7;

        int index = binarySearch(array, target);

        if (index != -1) {
            System.out.println("目标元素" + target + "的索引是：" + index);
        } else {
            System.out.println("没有找到目标元素" + target);
        }
    }
}

以上代码实现了一个简单的二分查找算法，首先定义了一个`binarySearch`方法用于查找目标元素在数组中的索引，然后在`main`方法中定义一个有序数组和目标元素，并调用`binarySearch`方法进行查找。如果找到目标元素，则输出目标元素的索引；如果未找到目标元素，则输出未找到的提示信息。

在上面的示例中，通过不断更新查找范围的左右边界，最终找到了目标元素7，并输出它在数组中的索引为3。如果目标元素不在数组中，则输出未找到的提示信息。

这就是使用Java编写的简单二分查找算法的实现。

### 回答3：
二分查找也称为折半查找，是一种高效的查找算法。在查找有序数组中的元素时，通过将数组分成两部分，将目标值与数组中间元素进行比较，可以快速确定目标值所在的范围，并且每一次比较都可以将查找范围减半，从而提高查找效率。

以下是用Java语言实现二分查找的示例代码：

public class BinarySearch {
    public static int binarySearch(int[] array, int target) {
        int left = 0;
        int right = array.length - 1;

        while (left <= right) {
            int mid = left + (right - left) / 2;

            if (array[mid] == target) {
                return mid;
            } else if (array[mid] < target) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }

        return -1;
    }

    public static void main(String[] args) {
        int[] array = {1, 3, 5, 7, 9};
        int target = 5;
        int index = binarySearch(array, target);

        if (index != -1) {
            System.out.println("目标值 " + target + " 在数组中的索引位置为 " + index);
        } else {
            System.out.println("目标值 " + target + " 不存在于数组中");
        }
    }
}

以上代码实现了一个名为`binarySearch`的静态方法，接受一个有序数组`array`和目标值`target`作为输入，返回目标值在数组中的索引位置。如果目标值不存在于数组中，则返回-1。

在`main`方法中，定义了一个示例数组`array = {1, 3, 5, 7, 9}`和目标值`target = 5`，然后调用`binarySearch`方法进行查找。程序将输出"目标值 5 在数组中的索引位置为 2"，表示目标值5在数组中的索引位置为2。