各位前辈，我还是个新手，在看毕向东老师的java基础视频。
今天看完之后开始自己写，然后遇到了一个问题，请各位前辈抽出些时间帮我查看一下：

1. class Tool
   
2. {
   
3.         //返回最大值
   
4.         public static int getMax(int[] arr)
   
5.         {
   
6.                 int max = 0;
   
7.                 for (int x=1;x<arr.length;x++ )
   
8.                 {
   
9.                         if (arr[x]>arr[max])
   
10.                         {
    
11.                                 swap(arr,x,max);
    
12.                         }
    
13.                        
    
14.                 }
    
15.                         return arr[max];
    
16.         }
    
17.        
    
18.         //返回最小值
    
19.         public static int getMin(int[] arr)
    
20.         {
    
21.                 int min = 0;
    
22.                 for (int x=1;x<arr.length;x++ )
    
23.                 {
    
24.                         if (arr[x]<arr[min])
    
25.                         {
    
26.                                 swap(arr,x,min);
    
27.                         }
    
28.                        
    
29.                 }
    
30.                         return arr[min];
    
31.         }
    
32. 
    
33.         //折半查找
    
34.         public static int halfSort(int[] arr,int key)
    
35.         {
    
36.                 int max=arr.length-1,min=0,mid=(max+min)>>>1;
    
37.                 while(key!=arr[mid])
    
38.                 {
    
39.                         mid=(max+min)>>>1;
    
40.                         if(key>arr[mid])
    
41.                         {
    
42.                                 min=mid+1;
    
43.                         }
    
44.                         else if(key<arr[mid])
    
45.                         {       
    
46.                                 max=mid-1;
    
47.                         }
    
48.                         else if(max<min)
    
49.                         {
    
50.                                 return -1;
    
51.                         }
    
52.                 }
    
53.                         return mid;
    
54.                        
    
55.         }
    
56. 
    
57.         //冒泡排序
    
58.         public static void bubbleSort(int[] arr)
    
59.         {
    
60.                 for (int x=0;x<arr.length-1;x++ )
    
61.                 {
    
62.                         for(int y=0;y<arr.length-x-1;y++)
    
63.                         {
    
64.                                 if(arr[y]>arr[y+1])
    
65.                                 {
    
66.                                         swap(arr,y,y+1);
    
67.                                 }
    
68.                         }
    
69.                 }
    
70.                         printArray(arr);
    
71.         }
    
72. 
    
73.         //选择排序
    
74.         public static void selectSort(int[] arr)
    
75.         {
    
76.                 for (int x=0;x<arr.length-1;x++ )
    
77.                 {
    
78.                         for(int y=x+1;y<arr.length-1;y++)
    
79.                         {
    
80.                                 if (arr[x]>arr[y])
    
81.                                 {
    
82.                                         swap(arr,x,y);
    
83.                                 }
    
84.                         }
    
85.                 }
    
86.                         printArray(arr);
    
87.         }
    
88.        
    
89.         //调换位置
    
90.         private static void swap(int[] arr,int a,int b)
    
91.         {
    
92.                 int temp = arr[a];
    
93.                 arr[a] = arr[b];
    
94.                 arr[b] = temp;
    
95.         }
    
96. 
    
97.         //打印数组
    
98.         private static void printArray(int[] arr)
    
99.         {
    
100.                         System.out.print("[");
     
101.                 for (int i=0;i<arr.length;i++)
     
102.                 {
     
103.                         if(i!=arr.length-1)
     
104.                         {
     
105.                                 System.out.print(arr[i]+",");
     
106.                         }
     
107.                         else
     
108.                                 System.out.print(arr[i]+"]"+"\n");
     
109.                 }
     
110.         }
     
111. }
     
112. 
     
113. class ArrayToolDemo
     
114. {
     
115.         public static void main(String[] args)
     
116.         {
     
117.         int[] arr={12,7,9,13,8,5,6,14};
     
118.         //tool.bubbleSort(arr);
     
119.         int x = Tool.getMin(arr);
     
120.         int y = Tool.getMax(arr);
     
121.         int z = Tool.halfSort(arr,14);
     
122.        
     
123.                 System.out.println("min="+x);
     
124.                 System.out.println("max="+y);
     
125.                 System.out.println(z);
     
126.        
     
127.         }
     
128. }
     

复制代码

编译通过，然后java ArrayTestDemo时不出结果。
然后我把x和y ，还有System.out.println("min="+x);
                System.out.println("max="+y);
注释掉，就可以出结果。
单独把z注释掉，保留x和y也可以出结果，但就是三个一起输出没有结果。
请各位前辈帮我检查一下，不胜感激！！

这个只需要改正一点，不是改正，你的方法也对，应该是修改：
只要将二班查找中的while(key!=arr[mid])改为while(min<=max)
至于具体原因，我也说不清楚，你自己悟悟吧，呵呵~~
代码如下：
//折半查找
        public static int halfSort(int[] arr,int key)
        {
                int max=arr.length-1,min=0,mid=(max+min)>>>1;
                //while(key!=arr[mid])
                while(min<=max)
                {
                        mid=(max+min)>>>1;
                        if(key>arr[mid])
                        {
                                min=mid+1;
                        }
                        else if(key<arr[mid])
                        {      
                                max=mid-1;
                        }
                        else if(max<min)
                        {
                                return -1;
                        }
                }
                        return mid;
                       
        }

李振元 发表于 2011-12-13 17:39
这个只需要改正一点，不是改正，你的方法也对，应该是修改：
只要将二班查找中的while(key!=arr[mid])改为w ...

这样的确可以了呢！
不过，原因还得想想~
多谢前辈！！感激不尽！！

qwert 发表于 2011-12-13 17:50
这样的确可以了呢！
不过，原因还得想想~
多谢前辈！！感激不尽！！

不是前辈，都是同学，呵呵~java这东西得慢慢来啊，一起努力！

李振元 发表于 2011-12-13 17:57
不是前辈，都是同学，呵呵~java这东西得慢慢来啊，一起努力！

哈哈~前辈，我悟到了~
我之前用getMin()和getMax()方法分别获取最小值和最大值，结果导致数组内的元素顺序都被打乱了。
而折半查找的特点在于只能对有序的数组进行查找。所以，出现了冲突。我把代码改了下，终于可以了！
谢谢前辈的提醒！

1.         //折半查找
   
2.         public static int halfSort(int[] arr,int key)
   
3.         {
   
4.                 int min=0,max=arr.length-1,mid=(max+min)>>1;//右移1位也是除2运算
   
5.                 while(key!=arr[mid])
   
6.                 {
   
7.                         mid=(min+max)>>1;
   
8.                         if(arr[mid]>key)
   
9.                                 max=mid-1;
   
10.                         else if(arr[mid]<key)
    
11.                                 min=mid+1;
    
12.                                  if(max<min)
    
13.                                 return -1;
    
14.                 }
    
15.                                 return mid;
    
16.                        
    
17.         }
    
18. class ArrayToolDemo
    
19. {
    
20.         public static void main(String[] args)
    
21.         {
    
22.         int[] arr={12,7,9,13,8,5,6,14};
    
23.        
    
24.         int x = Tool.getMin(arr);
    
25.         Tool.printArray(arr);
    
26.         int y = Tool.getMax(arr);
    
27.         Tool.printArray(arr);
    
28.         Tool.bubbleSort(arr);
    
29.         Tool.printArray(arr);
    
30.         int z = Tool.halfSort(arr,13);       
    
31.         System.out.println(z);
    
32.         }
    
33. }

复制代码

qwert 发表于 2011-12-13 18:24
哈哈~前辈，我悟到了~
我之前用getMin()和getMax()方法分别获取最小值和最大值，结果导致数组内的元素顺 ...

这不也像你学习了吗:lol