1. class  Test
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 int[] arr={12,6,72,34,36,7,6,5,8,2};
   
6.                 int index=halfSearch(arr,2);
   
7.                 System.out.println("index="+index);
   
8.         }
   
9. 
   
10.         public static int halfSearch(int[] arr,int key)
    
11.         {
    
12.                 int min,max,mid;
    
13.                 min=0;
    
14.                 max = arr.length-1;
    
15.                 mid = (max+min)/2;
    
16.                         
    
17.                         while (arr[mid]!=key)
    
18.                         {
    
19.                                 if (key>arr[mid])
    
20.                                                 min=mid+1;
    
21.                                 else if (key<arr[mid])
    
22.                                                 max=mid-1;
    
23.                                 
    
24.                                 if(min>max)
    
25.                                         return -1;
    
26.                                 mid=(min+max)/2;
    
27.                         }
    
28.                         return mid;
    
29.         }
    
30. }

复制代码

不知道错哪了 不管查哪个数都 是 index=-1 的结果。。。。

1.                         while (arr[mid]!=key)
   
2. 
   
3.                     {
   
4. 
   
5.                                if (key>arr[mid])
   
6. 
   
7.                                                 min=mid+1;
   
8. 
   
9.                                 else if (key<arr[mid])
   
10. 
    
11.                                                max=mid-1;
    
12. 
    
13.                              
    
14. 
    
15.                               if(min>max)
    
16. 
    
17.                                        return -1;
    
18. 
    
19.                               mid=(min+max)/2;
    
20. 
    
21.                       }
    
22. 
    

复制代码

这个while循换在return -1之前根本跳不出来，

你在比较min和max之前先输出min和max就知道怎么回事了，你要实现折半查找首先要将数列按有序化(递增或递减)排列，才可以，不然你找的那一半永远找不到想要的，没找的那一半到有你想要的

感觉代码 没有问题啊啊~~却怎么也找不出结果错哪了  疯了要

你看楼上，刚给你回复了

蓝色火焰 发表于 2012-2-26 21:39
你在比较min和max之前先输出min和max就知道怎么回事了，你要实现折半查找首先要将数列按有序化(递增或递减) ...

怎么跳不出来？ 当 key=arr[mid] 时它就跳出来了，结束循环 return mid

你这个是折半查找吧,第一步就错了,这个数组必须是有顺序的

蓝色火焰 发表于 2012-2-26 21:39
你在比较min和max之前先输出min和max就知道怎么回事了，你要实现折半查找首先要将数列按有序化(递增或递减) ...

知道为什么 非常感谢

不客气，大家一起加油吧

上面说的不错啊

import java.util.*;
class  Test

{

        public static void main(String[] args)

        {

                int[] arr={12,6,72,34,36,7,6,5,8,2};
                                Arrays.sort(arr);
                int index=halfSearch(arr,6);

                System.out.println("index="+index);

        }



        public static int halfSearch(int[] arr,int key)

        {

                int min,max,mid;

                min=0;

                max = arr.length-1;

                mid = (max+min)/2;

                        

                        while (arr[mid]!=key)

                        {

                                if (key>arr[mid])

                                                min=mid+1;

                                else if (key<arr[mid])

                                                max=mid-1;

                                

                                if(min>max)

                                        return -1;

                                mid=(min+max)/2;

                        }

                        return mid;

        }

}
这是折半查找的一个局限条件，必须是有序数组。