java二分搜索算法

二分查找又称折半查找，
优点是比较次数少，查找速度快，平均性能好；
其缺点是要求待查表为有序表，且插入删除困难。
因此，折半查找方法适用于不经常变动而查找频繁的有序列表。
首先，假设表中元素是按升序排列，将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置记录将表分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步查找前一子表，否则进一步查找后一子表。重复以上过程，直到找到满足条件的记录，使查找成功，或直到子表不存在为止，此时查找不成功。
算法简介

算法要求

必须采用顺序存储结构
2.必须按关键字大小有序排列。
算法复杂度

假设其数组长度为n，其算法复杂度为o（log（n））
下面提供一段二分查找实现的伪代码:
BinarySearch(max,min,des)
mid-<(max+min)/2
while(min<=max)
mid=(min+max)/2
if mid=des then
return mid
elseif mid >des then
max=mid-1
else
min=mid+1
return max
折半查找法也称为二分查找法，它充分利用了元素间的次序关系，采用分治策略，可在最坏的情况下用O(log n)完成搜索任务。它的基本思想是，将n个元素分成个数大致相同的两半，取a[n/2]与欲查找的x作比较，如果x=a[n/2]则找到x，算法终止。如 果x<a[n/2]，则我们只要在数组a的左半部继续搜索x（这里假设数组元素呈升序排列）。如果x>a[n/2]，则我们只要在数组a的右 半部继续搜索x。
二分查找法一般都存在一个临界值的BUG，即查找不到最后一个或第一个值。可以在比较到最后两个数时，再次判断到底是哪个值和查找的值相等。
2代码示例

pascal源代码
program jjzx(input,output);
var
a:array[1..10] of integer;
i,j,n,x:integer;
begin
writeln('输入10个从小到大的数：');
for i:=1 to 10 do read(a[i]);
writeln('输入要查找的数：');
readln(x);
i:=1; n:=10; j:=trunc((i+n)/2);
repeat
if a[j]>x then
begin
n:=j-1; j:=trunc((i+n)/2)
end
else if a[j]<x then
begin
i:=j+1; j:=trunc((j+n)/2)
end;
until (a[j]=x) or (i>=n) ;{为什么是这个结束循环条件}
if a[j]=x then
writeln('查找成功！位置是：',j:3)
else
writeln('查找失败，数组中无此元素！')
end.
C语言代码
int BinSearch(SeqList * R， int n , KeyType K )
{
    //在有序表R[0..n-1]中进行二分查找，成功时返回结点的位置，失败时返回-1
    int low=0，high=n-1，mid； //置当前查找区间上、下界的初值
    if(R[low].key==K)
    {
        return low ;
    }
    if(R[high].key==k)
        return high;
    while(low<=high)
    {
        //当前查找区间R[low..high]非空
        mid=low+((high-low)/2)；//使用 (low + high) / 2 会有整数溢出的问题（问题会出现在当low + high的结果大于表达式结果类型所能表示的最大值时，这样，产生溢出后再/2是不会产生正确结果的，而low+((high-low)/2)不存在这个问题
        if(R[mid].key==K)
        {
            return mid； //查找成功返回
        }
        if(R[mid].key>K)
            high=mid-1; //继续在R[low..mid-1]中查找
        else
            low=mid+1； //继续在R[mid+1..high]中查找
    }
    if(low>high)
        return -1； //当low>high时表示查找区间为空，查找失败
} //BinSeareh
Java代码
public class BinarySearch {
/**
* 二分查找算法
*
* @param srcArray 有序数组
* @param des 查找元素
* @return des的数组下标，没找到返回-1
*/
    public static int binarySearch(int[] srcArray, int des)
    {
        int low = 0;
        int high = srcArray.length-1;
        while(low <= high)
        {
            int middle = (low + high)/2;
            if(des == srcArray[middle])
            {
                return middle;
            }
            else if(des <srcArray[middle])
            {
                high = middle - 1;
            }
            else
            {
                low = middle + 1;
            }
        }
        return -1;
    }
    public static void main(String[] args)
    {
        int[] src = new int[] {1, 3, 5, 7, 8, 9};
        System.out.println(binarySearch(src, 3));
    }
}
AAuto代码
//二分查找
function binSearch(t,v ){
var p = #t;
var p2;
var b = 0;
do{
p2 = p;
p = b + math.floor( (p-b) / 2 ) //二分折半运算
if(p==b)return;
if( t[p] < v ){ //判断下限
b = p;
p = p2;
}
}while( t[p]>v ) //判断上限
return t[p]==v && p;
}
//测试
tab = {}
//创建数组，每个元素都是随机数
for(i=1;10 ;1){
tab[i] = math.random(1, 10000)
}
//插入一个已知数
table.push(tab,5632)
//排序
table.sort( tab)
io.open()
io.print( "数组",table.tostring(tab) )
io.print( "使用二分查找，找到5632在位置：",binSearch( tab,5632 ) )

PHP代码
// 递归版本
function bin_sch($array, $low, $high, $k){
if ($low <= $high){
$mid = intval(($low+$high)/2);
if ($array[$mid] == $k){
return $mid;
}elseif ($k < $array[$mid]){
return bin_sch($array, $low, $mid-1, $k);
}else{
return bin_sch($array, $mid+1, $high, $k);
}
}
return -1;
}
// 非递归版本
function binsearch($x, $a)
{
    $c = count($a);
    $lower = 0;
    $high = $c - 1;

    while ($lower <= $high)
    {
        $middle = intval(($lower + $high) / 2);
        if ($a[$middle] > $x)
            $high = $middle  - 1;
        else if ($a[$middle] < $x)
            $lower = $middle + 1;
        else
            return $middle;
    }

    return -1;
}
C++代码
int binSearch(const int *Array,int start,int end,int key)
{
int left,right;
int mid;
left=start;
right=end;
while (left<=right) { /注释中为递归算法，执行效率低，不推荐
mid=(left+right)/2;
/* if (key<Array[mid]) {
return(binSearch(Array,left,mid,key));
}
else if(key>Array[mid]){
return (binSearch(Array,mid+1,right,key));
}
else
return mid;
*/
if (key<Array[mid]) {
right=mid-1;
}
else if(key>Array[mid]){
left=mid+1;
}
else
return mid;
}
return -1;
}
AS3代码
public static function binSearch(list:Array, low:int, high:int,key:int):int
{
if (low > high) return -1;
var mid:int = low + int((high - low) / 2);
var index:int =-1
if (list[mid] == key)
{
index=mid;
}
else if (list[mid] < key)
{
low = mid + 1;
index=binSearch(list, low, high, key);
}
else
{
high = mid - 1;
index=binSearch(list, low, high, key);
}
return index;
}
JS 代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
var Arr = [3,5,6,7,9,12,15];
function binary(find,arr,low,high){
if(low <= high){
if(arr[low] == find)
return low;
if(arr[high] == find)
return high;
var mid = Math.ceil((high + low)/2);
if(arr[mid] == find){
return mid;
}else if(arr[mid] > find){
return binary(find,arr,low,mid-1);
}else{
return binary(find,arr,mid+1,high);
}
}
return -1;
}
binary(15,Arr,0,Arr.length-1);