二分法查找代码（C++ 输入10个数（有序）,用二分法进行查找某个数是否在其中.）

本文目录

• C++ 输入10个数(有序),用二分法进行查找某个数是否在其中.
• 二分法查找的C代码
• 怎么样利用二分法查找数据中的字串JAVA
• 二分法查找 C++
• 求二分法查找演示C语言源代码
• 二分法查找 c++
• 求解C#中的二分法查找(详细说明一下，有代码最好)
• 二分查找的代码示例
• 如何编写二分查找和顺序查找的C语言代码

C++ 输入10个数(有序),用二分法进行查找某个数是否在其中.

#include 《iostream》

using namespace std;
//a是查找的数组，二分法查找的前提条件是a数据的排序是有序的。key是待查找的变量，n是数组a的长度。
int binary( int *a, int key, int n )
{
    int left = 0, right = n - 1, mid = 0;
    mid = ( left + right ) / 2;
    while( left 《 right && a[mid] != key )
    {
        if( a[mid] 《 key )
        left = mid + 1;
        else if( a[mid] 》 key )
        right = mid - 1;
        mid = ( left + right ) / 2;
    }
    if( a[mid] == key )   return mid;
    return -1;
}

//调用：
//查找数组b在数组a中的下标的位置（当a中不存在b中的数据时，用-1代替）。
int main()
{
    int a = {1,2,3,4,5,6,7,8,9,12};
    int i,b,c;

    cout 《《 “从小到大输入10个整数:“;
    for(i=0;i《10;i++)
        cin  》》 a[i];

    cout 《《 “输入要查找的数:“;
    cin  》》 b;
    c = binary(a,b,10);
    if(c!=-1)
      cout 《《 “找到,序号:“《《c+1《《endl;
    else
      cout 《《“没找到“《《endl;
    return 0;
}

二分法查找的C代码

#include《stdio.h》//递归算法int recurbinary(int *a, int key, int low, int high){    int mid;    if(low 》 high)        return -1;    mid = (low + high)/2;    if(a[mid] == key) return mid;    else if(a[mid] 》 key)        return recurbinary(a,key,low,mid -1);    else        return recurbinary(a,key,mid + 1,high);}//非递归算法int binary( int *a, int key, int n ){    int left = 0, right = n - 1, mid = 0;    mid = ( left + right ) / 2;    while( left 《 right && a[mid] != key )    {        if( a[mid] 《 key ) {            left = mid + 1;        } else if( a[mid] 》 key ) {            right = mid - 1;        }        mid = ( left + right ) / 2;    }    if( a[mid] == key )        return mid;    return -1;}int main(){    int a = {1,2,3,4,5,6,7,8,9,12,13,45,67,89,99,101,111,123,134,565,677};    int b = {677,1,7,11,67};    int i;    for( i=0; i《sizeof(b)/sizeof(b); i++ )    {        //printf( “%d\n“, recurbinary(a, b[i],0,sizeof(a)/sizeof(a)-1) );        printf( “%d\n“, binary( a, b[i], sizeof(a)/sizeof(a)));    }    return 0;}

怎么样利用二分法查找数据中的字串JAVA

二分查找也称折半查找（Binary Search），它是一种效率较高的查找方法。但是，折半查找要求线性表必须采用顺序存储结构，而且表中元素按关键字有序排列。

二分查找优缺点

优点是比较次数少，查找速度快，平均性能好；

其缺点是要求待查表为有序表，且插入删除困难。

因此，折半查找方法适用于不经常变动而查找频繁的有序列表。
使用条件：查找序列是顺序结构，有序。

过程

首先，假设表中元素是按升序排列，将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置记录将表分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步查找前一子表，否则进一步查找后一子表。重复以上过程，直到找到满足条件的记录，使查找成功，或直到子表不存在为止，此时查找不成功。

利用循环的方式实现二分法查找

public class BinarySearch {
public static void main(String args) {
// 生成一个随机数组        int array = suiji();
// 对随机数组排序        Arrays.sort(array);
System.out.println(“产生的随机数组为： “ + Arrays.toString(array));

System.out.println(“要进行查找的值： “);
Scanner input = new Scanner(System.in);
// 进行查找的目标值        int aim = input.nextInt();

// 使用二分法查找        int index = binarySearch(array, aim);
System.out.println(“查找的值的索引位置： “ + index);

}

/**     * 生成一个随机数组     *
* @return 返回值，返回一个随机数组     */
private static int suiji() {
// random.nextInt(n)+m  返回m到m+n-1之间的随机数        int n = new Random().nextInt(6) + 5;
int array = new int[n];
// 循环遍历为数组赋值        for (int i = 0; i 《 array.length; i++) {
array[i] = new Random().nextInt(100);
}
return array;
}

/**     * 二分法查找  ---循环的方式实现     *
* @param array 要查找的数组     * @param aim 要查找的值     * @return 返回值，成功返回索引，失败返回-1     */
private static int binarySearch(int array, int aim) {
// 数组最小索引值        int left = 0;
// 数组最大索引值        int right = array.length - 1;
int mid;
while (left 《= right) {
mid = (left + right) / 2;
// 若查找数值比中间值小，则以整个查找范围的前半部分作为新的查找范围            if (aim 《 array[mid]) {
right = mid - 1;
// 若查找数值比中间值大，则以整个查找范围的后半部分作为新的查找范围            } else if (aim 》 array[mid]) {
left = mid + 1;
// 若查找数据与中间元素值正好相等，则放回中间元素值的索引      } else {
return mid;
}
}
return -1;
}}
运行结果演示：

由以上运行结果我们得知，如果要查找的数据在数组中存在，则输出该数据在数组中的索引；如果不存在则输出 -1 ，也就是打印 -1 则该数在数组中不存在，反之则存在。

四、利用递归的方式实现二分法查找

public class BinarySearch2 {
public static void main(String args) {
// 生成一个随机数组        int array = suiji();
// 对随机数组排序        Arrays.sort(array);
System.out.println(“产生的随机数组为： “ + Arrays.toString(array));

System.out.println(“要进行查找的值： “);
Scanner input = new Scanner(System.in);
// 进行查找的目标值        int aim = input.nextInt();

// 使用二分法查找        int index = binarySearch(array, aim, 0, array.length - 1);
System.out.println(“查找的值的索引位置： “ + index);
}

/**     * 生成一个随机数组     *     * @return 返回值，返回一个随机数组     */
private static int suiji() {
// Random.nextInt(n)+m  返回m到m+n-1之间的随机数        int n = new Random().nextInt(6) + 5;
int array = new int[n];
// 循环遍历为数组赋值        for (int i = 0; i 《 array.length; i++) {
array[i] = new Random().nextInt(100);
}
return array;
}

/**     * 二分法查找 ---递归的方式     *     * @param array 要查找的数组     * @param aim   要查找的值     * @param left  左边最小值     * @param right 右边最大值     * @return 返回值，成功返回索引，失败返回-1     */
private static int binarySearch(int array, int aim, int left, int right) {
if (aim 《 array[left] || aim 》 array[right]) {
return -1;
}
// 找中间值        int mid = (left + right) / 2;
if (array[mid] == aim) {
return mid;
} else if (array[mid] 》 aim) {
//如果中间值大于要找的值则从左边一半继续递归            return binarySearch(array, aim, left, mid - 1);
} else {
//如果中间值小于要找的值则从右边一半继续递归            return binarySearch(array, aim, mid + 1, array.length-1);
}
}}
运行结果演示：

总结：

递归相较于循环，代码比较简洁，但是时间和空间消耗比较大，效率低。在实际的学习与工作中，根据情况选择使用。通常我们如果使用循环实现代码只要不是太繁琐都选择循环的方式实现~

二分法查找 C++

在VC6.0中运行通过。
》代码一：（在代码三中指出了您没注意到的一些问题）》》：
#include《iostream》
using namespace std;
int main(void)
{
int BinSearch(int R,int K,int n);
int a,x,i,result;
for(i=0;i《10;i++)
cin》》a[i];
cin》》x;
result=BinSearch(a,x,10);
cout《《result《《endl;
return 0;
}
int BinSearch(int R,int K,int n)
{ //在有序表R[0..n-1]中进行二分查找，成功时返回结点的位置，失败时返回零
int low=0,high=n-1,mid; //置当前查找区间上、下界的初值
mid=(low+high)/2;
while(low《=high&&R[mid]!=K)
{ //当前查找区间R[low..high]非空
if(R[mid] 》K)
high=mid-1; //继续在R[low..mid-1]中查找
if(R[mid] 《K)
low=mid+1; //继续在R[mid+1..high]中查找
mid=(low+high)/2;
} //BinSeareh
if(R[mid]==K) return mid; //查找成功返回
else return -1; //当low》high时表示查找区间为空，查找失败
}
其实如果是在10个数中查找的话，参数n完全没必要
》代码二：》》：
#include《iostream》
using namespace std;
int main(void)
{
int BinSearch(int R,int K);
int a,x,i,result;
for(i=0;i《10;i++)
cin》》a[i];
cin》》x;
result=BinSearch(a,x);
cout《《result《《endl;
return 0;
}
int BinSearch(int R,int K)
{ //在有序表R[0..n-1]中进行二分查找，成功时返回结点的位置，失败时返回零
int low=0,high=10-1,mid; //置当前查找区间上、下界的初值
mid=(low+high)/2;
while(low《=high&&R[mid]!=K)
{ //当前查找区间R[low..high]非空
if(R[mid] 》K)
high=mid-1; //继续在R[low..mid-1]中查找
if(R[mid] 《K)
low=mid+1; //继续在R[mid+1..high]中查找
mid=(low+high)/2;
} //BinSeareh
if(R[mid]==K) return mid; //查找成功返回
else return -1; //当low》high时表示查找区间为空，查找失败
}
》代码三：》》：
如果您想在若干个（也就是您输入的元素个数不固定）你输入的元素中查找一个数，可以加一个参数n，用它传递数组中元素的个数
#include《iostream》
using namespace std;
int main(void)
{
int BinSearch(int R,int K,int n);//函数声明，如果定义在main函数之前，可以不要函数声明 具体参照参照xiang__198的代码
int a,x,i,result;
int num;
cout《《“您想输入几个数？“《《endl;
cin》》num;
cout《《“请输入“《《num《《“个已经由小到大排好序的数：“《《endl;
for(i=0;i《num;i++)
cin》》a[i];
cout《《“请输入待查找的数：“《《endl;
cin》》x;
result=BinSearch(a,x,num);//由于定义的函数要返回一个函数值，所以在主函数中要定义一个变量来接收这个返回值，数组元素做实参传递的是数组元素的首地址。故这里的调用写成result=BinSearch(a,x,num);，其中的a代表的是数组的首地址
cout《《“查找结果：“《《endl;
cout《《result《《endl;
return 0;
}
int BinSearch(int R,int K,int n)//不能写成int BinSearch(int R,int K,n)，注意形参不能为一个常量int BinSearch(int R,int K,10) 也不对
{ //在有序表R[0..n-1]中进行二分查找，成功时返回结点的位置，失败时返回零
int low=0,high=n-1,mid; //置当前查找区间上、下界的初值
mid=(low+high)/2;
while(low《=high&&R[mid]!=K)//查找区间不为空时，如果查找到，则R[mid]!=K，结束循环，否则缩小查找空间继续查找，你的这里少了一个R[mid]!=K，所以即使查找到，也不会输出查找结果，因为形成了死循环
{ //当前查找区间R[low..high]非空
if(R[mid] 》K)
high=mid-1; //继续在R[low..mid-1]中查找
if(R[mid] 《K)
low=mid+1; //继续在R[mid+1..high]中查找
mid=(low+high)/2;
} //BinSeareh
if(R[mid]==K)return mid; //查找成功返回
else return -1; //当low》high时表示查找区间为空，查找失败
}
对我的回答有疑问可以Hi我！恭候！

求二分法查找演示C语言源代码

二分法查找算法：

1. 主要思想是：假设数据是按升序排序的，对于给定值x，从序列的中间位置开始比较，如果当前位置值等于x，则查找成功；若x小于当前位置值，则在数列的前半段 中查找；若x大于当前位置值则在数列的后半段中继续查找，直到找到为止。

2. 时间复杂度:  O(log2n)。

3. C语言源代码(小例子）

  search函数即为核心代码：递归查找

二分法查找 c++

int binary_search(int *a, int length, int n) //length为数组长度， n为要查找的数
{
if(n《a||n》a[length-1])return -1; //没有合适的数
int left=0, right=length-1， middle;
while(left《right)
{
middle=(left+right)/2;
if(n》a[middle])left=middle;
else if(n《a[middle])right=middle;
else break; //这时求的值为n的数组下标，为middle；
}
while(middle》=0) //若有重复的n, 查找最前面的位置
{
if(a[middle]!=a[middle-1])return middle;
middle--;
}
}

求解C#中的二分法查找(详细说明一下，有代码最好)

int
search(int
a,
int
left,
int
right,
int
key)
{
int
mid;
//计算当前检索的数组的中间位置
while(left
《=
right)
mid
=
(left
+
right)/2
if
(
a[mid]
==
key)
{
return
mid;//如果中间元素与检索元素相等，则返回该元素的位置
}
else
if
(
a[mid]
《
key)
{
//如果中间元素比检索的元素小，则检索右边的子数组
left
=
mid+1;
}
else
{
//如果中间元素比检索的元素大，则检索左边的子数组
right
=
mid-1;;
}
}
printf(“你要找的元素没有找到。\n“);
return
-1;
}

二分查找的代码示例

/*二分查找：前提，该数组已经是一个有序数组，必须先排序，再查找。*/functionbinarySearch(&$array,$findVal,$leftIndex,$rightIndex){$middleIndex=round(($rightIndex+$leftIndex)/2);if($leftIndex》$rightIndex){echo’查无此数《br/》’;return;}if($findVal》$array[$middleIndex]){binarySearch($array,$findVal,$middleIndex+1,$rightIndex);}elseif($findVal《$array[$middleIndex]){binarySearch($array,$findVal,$leftIndex,$middleIndex-1);}else{echo找到数据:index=$middleIndex;value=$array[$middleIndex]《br/》;if($array[$middleIndex+1]==$array[$middleIndex]&&$leftIndex《$rightIndex){binarySearch($array,$findVal,$middleIndex+1,$rightIndex);}if($array[$middleIndex-1]==$array[$middleIndex]&&$leftIndex《$rightIndex){binarySearch($array,$findVal,$leftIndex,$middleIndex-1);}}}

如何编写二分查找和顺序查找的C语言代码

二分查找：
int search(int a,int x,int n)
{
int mid=0;
int low=0;
int high=n;
while(low《=high)
{
mid=(low+high)/2;
if(a[mid]==x)
{ return mid; }
else if(x《a[mid])
{ high=mid-1; }
else
{ low=high+1; }
}
return -1;
}
顺序查找：
int search(int a,int x,int n)
{
int i;
for(i=0;i《n;i++)
{
if(a[i]==x)
return i;
else
return -1;
}
}