使用Java语言用递归写一个二分查找算法

时间: 2023-02-19 22:51:37 浏览: 32
好的,那么你可以这样写: ``` public class BinarySearch { public static int binarySearch(int[] array, int target, int start, int end) { if (start > end) { return -1; } int mid = start + (end - start) / 2; if (array[mid] == target) { return mid; } else if (array[mid] < target) { return binarySearch(array, target, mid + 1, end); } else { return binarySearch(array, target, start, mid - 1); } } public static void main(String[] args) { int[] array = {1, 2, 3, 4, 5}; int target = 4; int index = binarySearch(array, target, 0, array.length - 1); System.out.println("The target is at index: " + index); } } ``` 在这段代码中,我们使用了递归的方式来实现二分查找算法。在每一次递归中,我们都计算出数组的中间位置,然后根据目标值与中间位置的值的大小关系来决定将查找范围缩小到数组的前半部分还是后半部分。如果找到了目标值,则返回目标值的下标;如果查找范围已经缩小到了0,则表明目标值不存在,返回-1。

相关推荐

### 回答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中,我们可以通过递归或者迭代的方式实现二分查找。下面是一个使用迭代方式实现的示例代码: 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语言编写的二分查找算法的示例代码: 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是数组的长度,因此效率非常高。
递归算法实现二分查找的Java代码可以参考以下示例: java public class BinarySearch { public static void main(String[] args) { int[] nums = {1, 2, 6, 15, 18, 20, 25, 27, 35, 40, 45, 56, 62, 78, 88}; int findValue = 35; int binaryResult = binarySearch(nums, 0, nums.length - 1, findValue); System.out.println("元素第一次出现的位置(从0开始):" + binaryResult); } private static int binarySearch(int[] nums, int start, int end, int findValue) { if (start <= end) { int middle = (start + end) / 2; if (findValue == nums[middle]) { return middle; // 查找值等于中间值直接返回 } else if (findValue < nums[middle]) { return binarySearch(nums, start, middle - 1, findValue); // 小于中间值,在中间值之前的数据中查找 } else { return binarySearch(nums, middle + 1, end, findValue); // 大于中间值,在中间值之后的数据中查找 } } return -1; } } 这个递归实现的二分查找算法首先检查开始下标start是否小于等于结束下标end,如果是,则计算中间下标middle。然后通过比较查找值findValue与中间值nums[middle]的大小,决定是在中间值之前的数据中查找还是在中间值之后的数据中查找,递归调用binarySearch方法。如果查找值等于中间值,则直接返回中间下标;如果查找值小于中间值,则在中间值之前的数据中查找,更新结束下标end为middle - 1;如果查找值大于中间值,则在中间值之后的数据中查找,更新开始下标start为middle + 1。如果开始下标大于结束下标,表示未找到查找值,返回-1。 这样的递归实现方式能够不断缩小查找范围,提高查找效率。123 #### 引用[.reference_title] - *1* [二分查找递归解法(java)](https://blog.csdn.net/weixin_51577444/article/details/123763009)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] - *2* *3* [Java常用算法-二分查找算法(两种方法实现)](https://blog.csdn.net/zengqing2010/article/details/120680127)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]
### 回答1: 好的,这是一个 Java 实现的二分查找法代码: public class BinarySearch { public static int binarySearch(int[] arr, int x) { int left = 0; int right = arr.length - 1; while (left <= right) { int mid = left + (right - left) / 2; if (arr[mid] == x) { return mid; } else if (arr[mid] < x) { left = mid + 1; } else { right = mid - 1; } } return -1; } } 在这个代码中,我们定义了一个方法 binarySearch,它接受一个整数数组和一个待查找的整数作为参数。然后,它在数组中使用二分查找法来查找该整数,并返回它的索引,如果没有找到,则返回 -1。 ### 回答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; // 找到目标元素,返回索引 } 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 = 7; int result = binarySearch(arr, target); if (result == -1) { System.out.println("目标元素不存在"); } else { System.out.println("目标元素的索引为: " + result); } } } 这个例子中,我们定义了一个二分查找的方法binarySearch。首先,我们将待查找的数组的左索引left和右索引right分别初始化为0和数组的长度减1。然后我们进入循环,直到left大于right为止。在每次循环中,我们计算中间索引mid,并比较中间元素arr[mid]与目标元素target的大小。如果arr[mid]等于target,则找到目标元素,返回mid;如果arr[mid]小于target,则目标元素应该在右侧部分数组中,我们将left更新为mid+1;如果arr[mid]大于target,则目标元素应该在左侧部分数组中,我们将right更新为mid-1。如果循环结束时仍然没有找到目标元素,则返回-1表示未找到。在main函数中,我们创建了一个示例数组arr和目标元素target,并调用binarySearch方法进行查找。如果返回结果为-1,则输出“目标元素不存在”,否则输出“目标元素的索引为:”并输出相应的索引值。 ### 回答3: 二分查找法是一种在有序数组中查找特定元素的算法。它使用迭代或递归的方式,每次将待搜索范围缩小一半,直到找到目标元素或确定不存在。以下是用JAVA编写的二分查找法的示例代码: 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方法接收一个有序数组和目标元素作为参数,然后通过不断更新左右边界来缩小搜索范围,直到找到目标元素或确定不存在。如果找到了目标元素,则返回其索引;如果不存在,则返回-1。在main方法中,我们定义一个有序数组arr和目标元素target,然后调用binarySearch方法进行查找,最后输出结果。给定上述示例的数组和目标元素,程序将输出目标元素的索引为3。
好的,我可以用中文回答您的问题。 如果您要使用Java编写一个二分查找算法,可以按照以下步骤进行: 1. 首先,定义一个方法来执行二分查找。该方法应该包含三个参数:一个整数数组、要查找的目标值和数组的起始索引。 2. 接下来,计算数组的中间索引。您可以使用以下代码来计算中间索引: int middleIndex = startIndex + (endIndex - startIndex) / 2; 这个公式将startIndex和endIndex相加,然后除以2,以获取中间索引。 3. 然后,检查目标值是否等于数组的中间元素。如果是,则返回中间索引。 4. 如果目标值小于中间元素,则递归调用该方法,传递startIndex和中间索引作为新的endIndex。 5. 如果目标值大于中间元素,则递归调用该方法,传递中间索引和endIndex作为新的startIndex。 6. 如果目标值不在数组中,则返回-1表示未找到。 以下是一个Java实现的示例代码: public class BinarySearch { public static int binarySearch(int[] array, int target, int startIndex, int endIndex) { if (startIndex > endIndex) { return -1; } int middleIndex = startIndex + (endIndex - startIndex) / 2; if (target == array[middleIndex]) { return middleIndex; } else if (target < array[middleIndex]) { return binarySearch(array, target, startIndex, middleIndex - 1); } else { return binarySearch(array, target, middleIndex + 1, endIndex); } } } 您可以在需要使用二分查找算法的程序中调用此方法。
### 回答1: 二分查找是一种在有序数组中查找特定元素的快速算法。下面是用 Java 实现二分查找的代码示例: 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; } else if (array[mid] < target) { left = mid + 1; } else { right = mid - 1; } } return -1; } 在上面的代码中,首先定义了左右两个指针 left 和 right,分别表示数组的左边界和右边界。在每次查找的过程中,我们计算中间索引 mid,并比较该索引对应的元素与目标元素的值,根据比较结果缩小查找范围,直到找到目标元素为止。如果最终查找失败,则返回 -1。 ### 回答2: 二分查找是一种在有序数组中查找元素的算法。实现二分查找可以通过递归或迭代的方式来实现,下面是用JAVA编写的迭代实现代码: 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, 2, 3, 4, 5, 6, 7, 8, 9, 10}; int target = 6; int result = binarySearch(arr, target); if (result == -1) { System.out.println("目标元素不存在"); } else { System.out.println("目标元素在数组中的索引为:" + result); } } } 以上代码实现了一个迭代版本的二分查找,首先定义了左边界和右边界,然后通过循环不断缩小查找范围,直到找到目标元素或者查找范围为空。如果找到了目标元素,则返回其在数组中的索引,否则返回-1表示目标元素不存在。 在以上代码中,需要查找的目标元素是6,该元素在数组中的索引为5,因此输出结果为"目标元素在数组中的索引为:5"。
### 回答1: Java中的二分查找(也称为折半查找)递归法的时间复杂度为 O(log n),其中 n 是查找范围内元素的数量。 这是因为每次递归调用都将查找范围缩小一半,因此最坏情况下,需要进行 log n 次递归调用才能找到目标元素。 需要注意的是,这种时间复杂度仅适用于已排序的数组,如果数组没有排序,则需要首先对其进行排序,这将增加一些时间复杂度。 ### 回答2: 在Java中,二分查找是一种常用的查找算法,递归法是实现二分查找的一种方式。二分查找的时间复杂度为O(logn),其中n是待查找的元素个数。 递归法的二分查找算法的时间复杂度与普通的二分查找时间复杂度相同,也是O(logn)。不同之处在于递归法需要额外的栈空间来保存递归调用的状态,所以递归法的空间复杂度相对较高。 递归法的二分查找算法是通过将待查找范围不断分为两半来进行查找的。每次将待查找范围分为两部分,然后判断目标元素与中间元素的大小关系,再根据这个关系来确定下一步查找的范围。递归调用的终止条件是找到目标元素或者待查找范围为空。 递归法的二分查找算法的主要优点是简洁易懂,代码逻辑清晰。但是由于递归调用会导致函数的调用栈不断增长,所以在处理大规模数据时可能会导致栈溢出的问题。为了解决这个问题,可以使用非递归的方式来实现二分查找。 总结来说,Java中使用递归法实现的二分查找算法的时间复杂度为O(logn),空间复杂度相对较高。在实际应用中,可以根据具体情况选择递归法或非递归法来实现二分查找。 ### 回答3: Java二分查找递归法的时间复杂度可以表示为O(logN)。 在二分查找的递归法中,首先需要对整个数组进行排序,这个排序操作的时间复杂度为O(NlogN)。然后,在每一次递归中,我们都将问题规模缩小为原来的一半。由于每次递归都会将问题规模缩小一半,因此最多需要进行logN次递归,才能找到目标元素(或确认不存在)。每次递归操作只需要O(1)的时间复杂度,因此总的时间复杂度可以近似表示为O(logN)。 需要注意的是,二分查找递归法的前提是数组已经有序。如果数组无序,那么需要额外的排序操作,时间复杂度会变为O(NlogN)。 总之,二分查找递归法的时间复杂度为O(logN)。
### 回答1: 以下是使用Java实现的二分查找寻找第一个大于k的值的位置的代码: java public static int binarySearch(int[] arr, int k) { int left = 0; int right = arr.length - 1; int mid; while (left <= right) { mid = (left + right) / 2; if (arr[mid] <= k) { left = mid + 1; } else { right = mid - 1; } } return left; } 在这个实现中,我们使用了左右指针和中间指针来查找第一个大于k的值的位置。如果中间元素小于等于k,则将左指针移到中间指针的右边;否则,将右指针移到中间指针的左边。最终,返回左指针的值即可。 注意,如果没有值大于k,则返回数组的长度。 ### 回答2: 当然,我很乐意帮你使用Java编写一个二分查找算法,用于寻找第一个大于给定值k的元素的位置。 首先,我们需要传入一个已经按升序排列的整数数组和一个目标值k作为参数。然后,我们可以采用递归的方式实现二分查找算法。 下面是使用Java编写的二分查找算法的示例代码: java public class BinarySearch { public static int binarySearch(int[] arr, int target, int left, int right) { if (left > right) return -1; int mid = (left + right) / 2; // 如果当前中间元素大于等于目标值,或者是第一个元素,则继续在左半部分进行查找 if ((mid == 0 || arr[mid - 1] < target) && arr[mid] >= target) return mid; // 如果当前中间元素小于目标值,继续在右半部分进行查找 else if (arr[mid] < target) return binarySearch(arr, target, mid + 1, right); // 如果当前中间元素大于目标值,继续在左半部分进行查找 else return binarySearch(arr, target, left, mid - 1); } public static void main(String[] args) { int[] arr = {1, 3, 5, 7, 9}; // 假设已按升序排列 int k = 4; // 给定目标值 int position = binarySearch(arr, k, 0, arr.length - 1); if (position != -1) System.out.println("第一个大于" + k + "的值的位置为:" + position); else System.out.println("不存在大于" + k + "的值"); } } 在上面的示例代码中,我们定义了一个名为binarySearch的方法,该方法接受一个整数数组arr、目标值target、数组的左边界left和数组的右边界right作为参数。如果找到第一个大于等于目标值的元素,将返回该元素的下标;否则,返回-1。 在main方法中,我们定义了一个给定的整数数组arr和目标值k。然后,我们调用binarySearch方法,并将结果打印出来。 希望以上代码能帮到你,如果还有其他问题,请随时告诉我。
### 回答1: 二分查找(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 - left) / 2; if (array[mid] == target) { return mid; } else if (array[mid] < target) { left = mid + 1; } else { right = mid - 1; } } return -1; } } 在这个例子中,我们使用了一个 while 循环,不断地计算中间位置的索引,并根据比较的结果来确定下一步的查找范围。当待查元素被找到时,返回它的索引;如果查找结束仍未找到,则返回 -1。 需要注意的是,二分查找的前提是数组必须是有序的。因此,在使用二分查找之前,需要对数组进行排序。 ### 回答2: 二分查找,也称为折半查找,是一种常见的查找算法。它适用于有序的数组或列表,并通过将目标值与数组或列表中间位置元素进行比较来决定继续查找的范围。 二分查找的基本步骤如下: 1. 确定查找的范围,一般为数组的起始位置和结束位置。 2. 计算查找的中间位置,并取中间位置的元素进行比较。 3. 如果中间位置的元素等于目标值,返回查找成功。 4. 如果中间位置的元素大于目标值,说明目标值在数组的前半部分,将结束位置设为中间位置减一,然后重复步骤2。 5. 如果中间位置的元素小于目标值,说明目标值在数组的后半部分,将起始位置设为中间位置加一,然后重复步骤2。 6. 如果起始位置大于结束位置,则返回查找失败。 二分查找的时间复杂度为O(logn),其中n为数组或列表的长度。相比于简单查找的线性时间复杂度O(n),二分查找的效率更高,尤其适用于大规模数据的查找。 然而,二分查找也有一些限制。首先,它要求待查找的数组或列表是有序的,如果数组或列表是无序的,则需要先进行排序。其次,二分查找只适用于静态的数据结构,即不支持频繁的插入、删除操作,否则每次操作之后都需要重新进行排序。 总的来说,二分查找是一种高效、快速的查找算法,尤其适用于大规模有序数组或列表的查找。在实际的软件开发中,需要根据具体的场景和需求选取适当的查找算法,以提高查找效率。 ### 回答3: Java的二分查找是一种在有序数组中查找特定元素的算法。这种查找算法将数组分为两个部分,通过比较待查找元素与数组中间元素的大小关系,确定待查找元素在哪一个部分中,并进一步缩小查找范围。这个过程通过递归实现,直到找到目标元素或者确定不存在目标元素为止。 二分查找的实现步骤如下: 1. 初始化起始位置low为数组第一个元素的索引,终止位置high为数组最后一个元素的索引。 2. 若起始位置低于等于终止位置,则执行以下操作: - 计算中间位置mid,mid的取值为(low+high)/2。 - 若中间位置的元素等于目标元素,则返回mid。 - 若中间位置的元素大于目标元素,则将终止位置high更新为mid - 1,缩小查找范围至左半部分。 - 若中间位置的元素小于目标元素,则将起始位置low更新为mid + 1,缩小查找范围至右半部分。 3. 若起始位置大于终止位置,则表示数组中不存在目标元素,返回-1。 二分查找的时间复杂度为O(log n),其中n为数组的长度。由于每次都将查找范围缩小一半,因此查找效率较高。但是,二分查找要求数组为有序数组,对于无序数组需要先进行排序操作。 在Java中,可以通过递归或者循环实现二分查找。递归实现方式更为简洁,但可能存在递归调用带来的性能开销和栈溢出的风险;循环实现方式相对繁琐,但效率较高。 总之,Java的二分查找是一种高效的查找算法,适用于有序数组中查找特定元素的场景。
### 回答1: 对于您提出的问题,我可以给出如下答案:Java中的二分法可以采用递归或迭代的方式实现。递归的步骤是:取中间值,与目标值比较;如果中间值等于目标值,则搜索成功;如果中间值大于目标值,则在左子数组中搜索;如果中间值小于目标值,则在右子数组中搜索。而迭代的步骤是:设置左右指针,左指针指向数组的第一个元素,右指针指向数组的最后一个元素,以此为基础,取中间值,与目标值比较;如果中间值等于目标值,则搜索成功;如果中间值大于目标值,则右指针向前移动;如果中间值小于目标值,则左指针向后移动。 ### 回答2: 二分法,也被称为二分查找,是一种常用的查找算法。它的原理是将已排序的数组或列表从中间分成两部分,然后选取中间值与目标值进行比较,若相等则返回,若中间值大于目标值,则在左半部分继续查找,若中间值小于目标值,则在右半部分继续查找,直到找到目标值或所有元素都被遍历。 下面是用JAVA编写一个二分法的实现代码: 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; } 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, 13, 15}; int target = 7; int result = binarySearch(arr, target); if (result == -1) { System.out.println("目标值不存在"); } else { System.out.println("目标值在数组中的索引位置为:" + result); } } } 在该代码中,binarySearch方法接受一个已排序的整型数组arr和一个目标值target作为参数。通过设定左边界left和右边界right来不断缩小范围,直到找到目标值或左边界大于右边界为止。最后返回目标值在数组中的索引位置。在main方法中,我们定义了一个示例数组arr和目标值target,并调用binarySearch方法进行查找,然后打印结果。 以上就是用JAVA编写二分法的代码实现和解释。使用二分法可以提高查找效率,尤其适用于大型有序数组或列表。 ### 回答3: 二分法,也称为折半查找法,是一种在有序数组中查找特定元素的算法。下面是用Java语言实现二分法的代码: 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; // 没有找到目标元素,返回-1 } public static void main(String[] args) { int[] array = {1, 2, 3, 4, 5, 6, 7}; int target = 3; int result = binarySearch(array, target); if (result != -1) { System.out.println("目标元素存在于数组中,索引为:" + result); } else { System.out.println("目标元素不存在于数组中"); } } } 以上代码实现了二分法的逻辑。首先,定义左边界left为数组的起始位置,右边界right为数组的结束位置。然后,进入循环,每次计算中间位置mid,然后判断中间位置的元素与目标元素的大小关系。如果中间元素等于目标元素,则表示找到目标元素,返回其索引。如果中间元素小于目标元素,则目标元素应在右半部分,更新左边界为mid + 1。如果中间元素大于目标元素,则目标元素应在左半部分,更新右边界为mid - 1。循环继续直到左边界大于右边界,表示未找到目标元素,返回-1。 在主函数中,创建一个有序数组array,定义目标元素target为3。然后调用binarySearch方法进行查找,并将结果存储在result中。最后根据result的值判断目标元素是否存在于数组中,并输出相应的提示信息。

最新推荐

干货!MySQL 数据库开发规范.docx

你真的会写一手好SQL吗?你真的深入了解数据库吗?你真的对MYSQL很理解吗?来自一线大厂资深数据库开发工程师的分享,纯粹干货,值得拥有。

基于51单片机的usb键盘设计与实现(1).doc

基于51单片机的usb键盘设计与实现(1).doc

"海洋环境知识提取与表示:专用导航应用体系结构建模"

对海洋环境知识提取和表示的贡献引用此版本:迪厄多娜·察查。对海洋环境知识提取和表示的贡献:提出了一个专门用于导航应用的体系结构。建模和模拟。西布列塔尼大学-布雷斯特,2014年。法语。NNT:2014BRES0118。电话:02148222HAL ID:电话:02148222https://theses.hal.science/tel-02148222提交日期:2019年HAL是一个多学科的开放存取档案馆,用于存放和传播科学研究论文,无论它们是否被公开。论文可以来自法国或国外的教学和研究机构,也可以来自公共或私人研究中心。L’archive ouverte pluridisciplinaire论文/西布列塔尼大学由布列塔尼欧洲大学盖章要获得标题西布列塔尼大学博士(博士)专业:计算机科学海洋科学博士学院对海洋环境知识的提取和表示的贡献体系结构的建议专用于应用程序导航。提交人迪厄多内·察察在联合研究单位编制(EA编号3634)海军学院

react中antd组件库里有个 rangepicker 我需要默认显示的当前月1号到最后一号的数据 要求选择不同月的时候 开始时间为一号 结束时间为选定的那个月的最后一号

你可以使用 RangePicker 的 defaultValue 属性来设置默认值。具体来说,你可以使用 moment.js 库来获取当前月份和最后一天的日期,然后将它们设置为 RangePicker 的 defaultValue。当用户选择不同的月份时,你可以在 onChange 回调中获取用户选择的月份,然后使用 moment.js 计算出该月份的第一天和最后一天,更新 RangePicker 的 value 属性。 以下是示例代码: ```jsx import { useState } from 'react'; import { DatePicker } from 'antd';

基于plc的楼宇恒压供水系统学位论文.doc

基于plc的楼宇恒压供水系统学位论文.doc

"用于对齐和识别的3D模型计算机视觉与模式识别"

表示用于对齐和识别的3D模型马蒂厄·奥布里引用此版本:马蒂厄·奥布里表示用于对齐和识别的3D模型计算机视觉与模式识别[cs.CV].巴黎高等师范学校,2015年。英语NNT:2015ENSU0006。电话:01160300v2HAL Id:tel-01160300https://theses.hal.science/tel-01160300v22018年4月11日提交HAL是一个多学科的开放获取档案馆,用于存放和传播科学研究文件,无论它们是否已这些文件可能来自法国或国外的教学和研究机构,或来自公共或私人研究中心。L’archive ouverte pluridisciplinaire博士之路博士之路博士之路在获得等级时,DOCTEURDE L'ÉCOLE NORMALE SUPERIEURE博士学校ED 386:巴黎中心数学科学Discipline ou spécialité:InformatiquePrésentée et soutenue par:马蒂厄·奥布里le8 may 2015滴度表示用于对齐和识别的Unité derechercheThèse dirigée par陪审团成员équipe WILLOW(CNRS/ENS/INRIA UMR 8548)慕尼黑工业大学(TU Munich�

valueError: Pandas data cast to numpy dtype of object. Check input data with np.asarray(data).

这个错误通常发生在使用 Pandas DataFrame 时,其中包含了一些不能被转换为数字类型的数据。 解决方法是使用 `pd.to_numeric()` 函数将数据转换为数字类型。例如: ```python import pandas as pd import numpy as np # 创建一个包含字符串和数字的 DataFrame df = pd.DataFrame({'A': ['a', 'b', 'c'], 'B': [1, 2, '3']}) # 尝试将整个 DataFrame 转换为数字类型会报错 np.asarray(df, dtype=np.float) # 使

基于VC--的五子棋程序设计与实现毕业设计.doc

基于VC--的五子棋程序设计与实现毕业设计.doc

体系结构驱动的普遍性应用程序中

体系结构驱动的普遍性应用程序的自主适应艾蒂安·甘德里勒引用此版本:艾蒂安·甘德里勒。由体系结构驱动的普遍性应用程序的自主适应。无处不在的计算。格勒诺布尔大学,2014年。法语。NNT:2014GRENM078。电话:01215004HAL ID:电话:01215004https://theses.hal.science/tel-01215004提交日期:2015年HAL是一个多学科的开放存取档案馆,用于存放和传播科学研究论文,无论它们是否被公开。论文可以来自法国或国外的教学和研究机构,也可以来自公共或私人研究中心。L’archive ouverte pluridisciplinaire论文要获得的等级格勒诺布尔大学博士专业:计算机科学部长令:2006年提交人艾蒂安·G·安德里尔论文由Philippe LAlanda指导由Stephanie CHollet共同指导在格勒诺布尔计算机科学实验室编写数学、信息科学与技术、计算机科学博士体系结构驱动的普遍性应用程序的自主适应论文�

STM32F103 RCT6 LCD显示正弦波并且设置可以调节振幅的触摸按键代码

以下是基于STM32F103RCT6和Keil MDK-ARM开发环境的LCD显示正弦波并且设置可以调节振幅的触摸按键代码: ```c #include "stm32f10x.h" #include "lcd.h" //LCD驱动库 #include "math.h" //数学库 #define PI 3.14159 //圆周率 void delay_ms(uint16_t n); int main(void) { float amplitude = 20; //振幅 float frequency = 1; //频率 float phase = 0; //相位