求大神帮写一下数组折半查找的代码   ！！！

1.     public static int splitHalf(int[] arrayData,int searchData,int start,int end){  
   
2.         int index = (start + end)/2;  
   
3.         int data = arrayData[index];  
   
4.         if(start > end ){  
   
5.             return -1;  
   
6.         }  
   
7.         if(data == searchData){  
   
8.             return index;  
   
9.         }else{  
   
10.             if(data < searchData){  
    
11.                 return splitHalf(arrayData,searchData,index+1,end);  
    
12.             }else{  
    
13.                 return splitHalf(arrayData,searchData,start,index-1);  
    
14.             }  
    
15.         }  
    
16.     }  
    
17.       
    
18.    当然我们也可以直接调用方法。Arrays.binarySearch();
    
19.     public static void main(String[] args) {  
    
20.         int[] array = { 3,5,11,17,21,23,28,30,32,50};  
    
21.         System.out.println(array.length);  
    
22.         int isExist = splitHalf(array,(int)50,0,array.length - 1);  
    
23.         System.out.println("isExist : "+isExist);  
    
24.     }

复制代码

splitHalf这个函数是干嘛用的   有没有用for循环写的那个代码

1. /*
   
2. * 折半查找
   
3. * 思路：
   
4. * 折半查找的前提是，数组已经是有序的，这里我们以升序为例。
   
5. * 每一次用关键词X与数组中间元素比较，X小于中间元素，则往后面查找，如果X大于中间元素，则往前面查找。
   
6. * 下一次查找也是按照前面的思想，继续让关键字与中间元素比较。
   
7. * 直到查找到与X相等的元素，或者不满足继续查找的条件，查找结束。
   
8. * 若查找成功返回出现X的位置，查找失败返回-1；
   
9. */
   
10. 
    
11. package 查找算法;
    
12. 
    
13. public class ZheBan {
    
14.         private static int[] array = new int[] { 1, 3, 5, 7, 9, 11, 13, 15, 17, 19 };
    
15. 
    
16.         public static void main(String[] arguments) {
    
17.                 System.out.println(search(0, array.length - 1, 3));
    
18.         }
    
19. 
    
20.         // 我们为查找单独定义一个函数，因为折半查找会用到递归的思想，会多次回调这个函数
    
21.         // 这个函数会返回一个整型的数据
    
22.         private static int search(int left, int right, int x) {
    
23.                 if (left > right)
    
24.                         return -1;
    
25.                 int middle = (left + right) / 2;// 求得数组中间元素
    
26.                 if (x == array[middle])
    
27.                         return middle;
    
28.                 else if (x < array[middle])
    
29.                         return search(left, middle - 1, x);
    
30.                 else
    
31.                         return search(middle + 1, right, x);
    
32.         }
    
33. }
    

复制代码

/*
要进行折半查找，必须先保证数组是有序的
*/
class Test
{
        public static void main(String[] args)
        {
                int[] arr = {1,2,3,7,12,15};//定义一个有序数组
                int index = binarySeek(arr,7);

                System.out.println("index="+index);
        }
        public static int binarySeek(int[] arr, int key)
        {
                int max,min,mid;//定义两个变量代表数组的最大角标，中间角标和最小角标
                max = arr.length-1;
                min = 0;
               
                for (int x=0; x<arr.length; x++)//使用for循环遍历数组，获取里面的元素
                {
                        mid = (max+min)>>1;//相当于(max+min)/2;

                        if(arr[mid]>key)//如果要查找的值比中间角标对应的值要小，
                                max = mid - 1;//就把中间角标向左移一位在赋值给max
                        else if(arr[mid]<key)
                        {
                                min = mid + 1;
                        }else
                                return mid;//如果要查找的键值的角等于mid，则返回mid
                }
                return -1;//如果要查找的值不存在，则返回-1；
        }
}

/*
        折半查找。提高效率，但是必须要保证该数组是有序的数组。
        */
        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 = (max+min)/2;
                }
                return mid;
        }
/*
        折半的第二种方式。
        */
        public static int halfSearch_2(int[] arr,int key)
        {
                int min = 0,max = arr.length-1,mid;

                while(min<=max)
                {
                        mid = (max+min)>>1;

                        if(key>arr[mid])
                                min = mid + 1;
                        else if(key<arr[mid])
                                max = mid - 1;
                        else
                                return mid;
                }
                return -1;
        }
        使用时调用这两个方法传入数组和要查找的值即可，

谢谢各位大神的热心帮助 ，问题已解决真心谢谢大家

Smile小思 发表于 2015-6-8 16:06
/*
        折半查找。提高效率，但是必须要保证该数组是有序的数组。
        */

谢谢你的两种方法，不过我感觉for循环比较好，可能是习惯问题。不过还是谢谢你   帮我解决了问题。

存在感很差 发表于 2015-6-8 13:04

谢谢你的详细解答

有序是前提，重复会不同，记住了额

谢谢，已记住！

问题已解决，怎么改为已解决