这是从CSDN的论坛上看到的一道题目，要求使用二分法从一个数组中查询出某特定数字是否存在，若存在，输出其位置。这是使用的非递归的方法实现的。
源码：
package
com.zhaozy.sort;
import
java.util.Scanner;
/**
*
给定一个数组和一个特定的整数，找出整数在数组中的位置
*
*
@author
zhaozy
*
*/
public
class
BinarySearch {
public
static
void
main(String[] args) {
int
[] dataset =
new
int
[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
Scanner s =
new
Scanner(System.
in
);
System.
out
.println(
"
请输入要查询的整数：
"
);
int
num = s.nextInt();
int
midIndex = findNum
(dataset, num);
if
(midIndex == -1) {
System.
out
.println(
"
此数不存在！
"
);
}
else
{
System.
out
.println(
"
位置为：
"
+ midIndex);
}
}
public
static
int
findNum(
int
[] dataset,
int
data) {
int
beginIndex = 0;
int
endIndex = dataset.
length
- 1;
int
midIndex = -1;
if
(data < dataset[beginIndex] || data > dataset[endIndex]
|| beginIndex > endIndex) {
return
-1;
}
while
(beginIndex <= endIndex) {
midIndex = (beginIndex + endIndex) / 2;
System.
out
.println(midIndex);
if
(data > dataset[midIndex]) {
beginIndex = midIndex + 1;
}
else
if
(data < dataset[midIndex]) {
endIndex = midIndex - 1;
}
else
{
return
midIndex;
}
}
return
-1;
}
}
整个程序都是使用的数组实现的，说实话，自己以前一直很看不起数组，以为他的使用范围很局限，不像集合那样的灵活，但我发现，我错了，(⊙o⊙)
还有一种是使用递归实现的，网上一直有人说递归的使用降低了代码的执行效率，以为自己没有太多深入的研究，所以两种方法都写上，以后好好研究一下。
使用递归的实现方法：
源码：
package
com.zhaozy.sort;
import
java.util.Scanner;
/**
*
使用递归
*
*
@author
zhaozy
*
*/
public
class
BinarySearch2 {
public
static
void
main(String[] args) {
int
[] dataset =
new
int
[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
Scanner scanner =
new
Scanner(System.
in
);
System.
out
.println(
"
请输入要查找的数据：
"
);
int
data = scanner.nextInt();
BinarySearch2 search =
new
BinarySearch2();
int
position = search.search(dataset, data, 0, dataset.
length
- 1);
if
(position == -1) {
System.
out
.println(
"
当前数组中没有此数据！
"
);
}
else
{
System.
out
.println(
"
在数组中的位置为：
"
+ position);
}
}
/**
*
*
@param
dataset
*
@param
data
*
@param
beginIndex
*
@param
endIndex
*
@return
要找的值在数组中的位置
*/
public
int
search(
int
[] dataset,
int
data,
int
beginIndex,
int
endIndex) {
//
取出中间的数据，作为标准进行判断
int
midIndex = (beginIndex + endIndex) / 2;
//
如果中间的数据大于数组的最大值
||
中间的数据小于数组的最小值
||beginIndex>endIndex
直接返回没有找到的信息
if
(data > dataset[endIndex] || data < dataset[beginIndex]
|| beginIndex > endIndex) {
return
-1;
}
if
(data < dataset[midIndex]) {
return
this
.search(dataset, data, beginIndex, midIndex - 1);
}
else
if
(data > dataset[midIndex]) {
return
this
.search(dataset, data, midIndex + 1, endIndex);
}
else
{
return
midIndex;
}
}
}
这是从CSDN的论坛上看到的一道题目，要求使用二分法从一个数组中查询出某特定数字是否存在，若存在，输出其位置。
源码：
package
com.zhaozy.sort;
import
java.util.Scanner;
/**
*
给定一个数组和一个特定的整数，找出整数在数组中的位置
*
*
@author
zhaozy
*
*/
public
class
BinarySearch {
public
static
void
main(String[] args) {
int
[] dataset =
new
int
[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
Scanner s =
new
Scanner(System.
in
);
System.
out
.println(
"
请输入要查询的整数：
"
);
int
num = s.nextInt();
int
midIndex = findNum
(dataset, num);
if
(midIndex == -1) {
System.
out
.println(
"
此数不存在！
"
);
}
else
{
System.
out
.println(
"
位置为：
"
+ midIndex);
}
}
public
static
int
findNum(
int
[] dataset,
int
data) {
int
beginIndex = 0;
int
endIndex = dataset.
length
- 1;
int
midIndex = -1;
if
(data < dataset[beginIndex] || data > dataset[endIndex]
|| beginIndex > endIndex) {
return
-1;
}
while
(beginIndex <= endIndex) {
midIndex = (beginIndex + endIndex) / 2;
System.
out
.println(midIndex);
if
(data > dataset[midIndex]) {
beginIndex = midIndex + 1;
}
else
if
(data < dataset[midIndex]) {
endIndex = midIndex - 1;
}
else
{
return
midIndex;
}
}
return
-1;
}
}
整个程序都是使用的数组实现的，说实话，自己以前一直很看不起数组，以为他的使用范围很局限，不像集合那样的灵活，但我发现，我错了，(⊙o⊙)
分享到：
相关推荐
结合快速排序和二分查找，可以先使用快速排序将数组排序，然后在需要查找元素时使用二分查找，这样可以大大提高查找效率，因为快速排序后的数组是有序的，适合二分查找。 在"BinarySearch"这个文件中，可能包含了...
结合这些知识点，开发者可以创建一个Java程序，首先从文件中读取数据到数组，然后使用选择排序对数组进行排序，最后利用二分查找在排序后的数组中查找特定元素。这是一个典型的文件操作与算法应用的实例。
用户可以选择进行注册、查询用户信息、快速排序用户数组或使用二分查找特定用户。快速排序方法`quicksort()`用于对客户对象数组按照ID升序排序，而`BinarySearch()`方法则用于在排序后的数组中查找具有特定ID的用户...
二分查找适用于已排序的数组或列表，通过不断将查找区间减半，直到找到目标元素或者确定不存在为止。它的优点在于时间复杂度为O(log n)，远优于线性查找的O(n)。 接下来，我们转向排序算法。排序是将一组数据按照...
二分查找，又称折半查找，是一种在有序数组中查找特定元素的搜索算法。其基本步骤如下： 1. 计算数组中间位置的索引。 2. 如果目标值等于中间元素，则查找结束。 3. 如果目标值小于中间元素，那么在数组的左半部分...
二分查找，也称为折半查找，是一种在有序数组中查找特定元素的搜索算法。它的基本思想是通过不断缩小搜索范围，将问题规模减半，从而提高搜索效率。当数组已经排序时，二分查找可以达到O(log n)的时间复杂度，比线性...
二分查找是一种查找算法，用于在已排序的数组中查找特定的元素。 前提：给我们的数组是有序的。 步骤图解： 我们查找 46 ，第一次定义 start，end 变量分别问 0 和数组长度，定义变量med=start+end/2; 然后我们...
二分查找，也被称为折半查找，是一种在有序数组中查找特定元素的搜索算法。它的基本思想是将数组分成两半，然后比较中间元素与目标值，根据比较结果决定是在左半部分还是右半部分继续查找。这个过程会一直重复，直到...
`main`函数中，在快速排序数组后，通过用户输入的值`t`进行二分查找，找到对应的元素并输出其在数组中的位置。二分查找的时间复杂度为O(log n)，相比线性查找效率更高。 ### C++中的应用 在C++中，快速排序和二分...
1. **数组必须是有序的**：这是二分查找的前提条件之一，如果数组无序，需要先对数组进行排序。 2. **数据类型**：二分查找适用于数值型数据，对于非数值型数据（如字符串），需要定义合适的比较方法。 3. **边界...
快速排序常用于大规模数据的排序，如数据库、数据分析等场景，而二分查找则常用于在已排序的数据结构中快速定位目标元素，例如在大型字典或电话簿中查找特定条目。在内存有限的情况下，它们都是优化性能的有效工具，...
**二分查找** 是一种在有序数组中查找特定元素的搜索算法。它的基本思想是将数组分成两个部分，每次比较中间元素与目标值，如果目标值等于中间元素，则查找结束；如果目标值小于中间元素，那么在左半部分继续查找；...
二分查找是一种在有序数组中查找特定元素的搜索算法。它的基本思想是每次将查找区间减半，直到找到目标元素或者区间为空。二分查找的时间复杂度为O(log n)，效率远高于线性查找。在C#中，实现二分查找通常包括以下...
二分查找是一种在有序数组中查找特定元素位置的算法，它利用数组元素排序的特性，通过比较数组中间元素与目标值的大小，将查找区间缩半来加快查找速度。该算法适用于有序集合，能够将时间复杂度从线性查找的O(n)降低...
二分查找，也被称为折半查找，是一种在有序数组中高效地查找特定元素的搜索算法。这个算法的主要思想是利用数组的有序性，通过不断缩小查找范围，直到找到目标值或者确定目标值不存在为止。本篇文章将深入探讨二分...
二分查找算法是一种在有序数组中寻找特定元素的搜索算法，具有高效的时间复杂度，是计算机科学中的一个重要概念。在给定的标题“二分查找算法”和描述“二分查找，完整工程文件，源代码，VS2010”中，我们可以推测这...
折半查找算法，也称为二分查找算法，是一种在有序序列中快速定位特定元素的技术。由于其高效性和广泛的适用性，二分查找在计算机科学领域得到了广泛的应用，尤其在处理大数据量的有序数据时，其优势更为明显。本文将...
在给定的升序排列的数组a[0:n-1]中，二分查找的目标是找到特定元素x的位置，或者确认元素不在数组中。算法的基本步骤如下： 1. **分解**：将数组分为左半部分和右半部分，中间元素的索引为mid。 2. **解决**：比较...
首先，二分查找是一种在有序数组中查找特定元素的搜索算法。其基本思想是通过不断将待查找的区间减半来快速定位目标值。以下是二分查找的步骤： 1. 计算数组的中间索引。 2. 检查中间元素是否为目标值，如果是，则...
二分查找算法，也称为折半查找算法，是一种在有序数组中查找特定元素的高效搜索方法。该算法的基本思想是通过比较数组中间元素与目标值的大小，将搜索范围缩小到一半，这样每次比较都可以将待查找区间减半，从而达到...