用JAVA语言写一段代码，通过递归算法实现折半查找问题

当然可以，以下是Java语言实现折半查找的递归算法代码：

public static int binarySearch(int[] arr, int target, int left, int right) {
if (left > right) {
return -1;
}
int mid = (left + right) / 2;
if (arr[mid] == target) {
return mid;
} else if (arr[mid] > target) {
return binarySearch(arr, target, left, mid - 1);
} else {
return binarySearch(arr, target, mid + 1, right);
}
}

其中，arr为有序数组，target为要查找的目标值，left为数组左边界，right为数组右边界。如果找到了目标值，则返回其下标，否则返回-1。

相关问题

用java写一个二分查找

### 回答1：
下面是一个 Java 中的二分查找算法的例子：

public static int binarySearch(int[] array, int key) {
    int low = 0;
    int high = array.length - 1;

    while (low <= high) {
        int mid = (low + high) / 2;
        int midVal = array[mid];

        if (midVal < key) {
            low = mid + 1;
        } else if (midVal > key) {
            high = mid - 1;
        } else {
            return mid;  // key found
        }
    }
    return -1;  // key not found
}

该算法的时间复杂度为 O(log n)，其中 n 是数组的长度。

使用方法：

int[] array = {2, 4, 6, 8, 10, 12, 14, 16};
int key = 10;
int index = binarySearch(array, key);
if (index >= 0) {
    System.out.println("Key found at index: " + index);
} else {
    System.out.println("Key not found");
}

希望这对你有帮助！

### 回答2：
二分查找是一种在有序数组中查找目标元素的常用算法。它的基本思想是将数组分为两个部分，然后判断目标元素在哪一部分中，并再次将该部分继续划分为两个部分，直到找到目标元素或者确定目标元素不存在。

在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;
    }

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

        int result = binarySearch(arr, target);
        if (result == -1) {
            System.out.println("目标元素不存在");
        } else {
            System.out.println("目标元素的索引为：" + result);
        }
    }
}

在上述代码中，binarySearch方法接收一个有序数组arr和一个目标元素target作为参数。使用两个指针left和right来表示当前查找范围的左右边界，然后在循环中计算中间索引mid，并通过与target的比较来确定目标元素在哪一部分中。如果arr[mid]等于target，则返回mid；如果arr[mid]小于target，则将left指针移动到mid+1；如果arr[mid]大于target，则将right指针移动到mid-1。重复这个过程，直到找到目标元素或者范围缩小到空，即left大于right，则返回-1表示目标元素不存在。

在示例代码的main方法中，我们定义一个有序数组arr和一个目标元素target，然后调用binarySearch方法进行查找。如果返回的结果为-1，则表示目标元素不存在；否则，返回的结果就是目标元素的索引。最后，我们将结果打印出来。

### 回答3：
二分查找也被称为折半查找，是一种高效的查找算法。它的基本思想是通过比较中间元素和目标元素的大小关系，来确定目标元素可能出现的位置，并逐步缩小搜索范围，最终找到目标元素。

以下是用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) / 2;
            
            if (arr[mid] == target) {
                return mid; // 目标元素找到，返回索引
            }
            
            if (arr[mid] < target) {
                left = mid + 1; // 目标元素在右半部分，更新左边界
            } else {
                right = mid - 1; // 目标元素在左半部分，更新右边界
            }
        }
        
        return -1; // 目标元素不存在，返回-1
    }

    public static void main(String[] args) {
        int[] arr = {2, 5, 8, 12, 16, 23, 38, 56, 72, 91};
        int target = 23;
        
        int result = binarySearch(arr, target);
        if (result != -1) {
            System.out.println("目标元素在索引 " + result + " 处找到。");
        } else {
            System.out.println("目标元素不存在。");
        }
    }
}

以上代码中，`binarySearch`方法接受一个已排序的整型数组和目标元素作为参数，返回目标元素在数组中的索引（如果存在），否则返回-1。主函数中定义了一个已排序数组`arr`和目标元素`target`，并调用`binarySearch`方法进行查找。运行结果输出目标元素在数组中的索引，或者提示目标元素不存在。

这段代码通过不断更新搜索范围的左右边界，使用循环实现了二分查找算法。它的时间复杂度是O(log n)，其中n是数组的长度，因此效率非常高。