冒泡，选择，二分查询之java实现

1.选择法排序

转载出自：http://blog.csdn.net/wentasy/article/details/7438064

选择法排序的基本思想是：首先从待排序的n个数中找出最小的一个与array[0]对换；再将array [1]到array [n]中的最小数与array [1]对换，依此类推。每比较一轮，找出待排序数中最小的一个数进行交换，共进行n-1次交换便可完成排序。选择法排序每执行一次外循环只进行一次数组元素的交换，可使交换的次数大大减少。

       下图演示这一过程：

 

          代码实现：

        

[java]  view plain copy

1. public class SelectSort{  
2.     public static void main(String [] args){  
3.       
4.         int a[] = {1, 2, 3, 56, 45, 22, 22, 26, 89, 99, 100};  
5.           
6.         System.out.println("排序前：");  
7.         for (int i = 0; i < a.length; ++ i){  
8.             System.out.print(a[i] + " ");  
9.         }  
10.           
11.         selectSort(a);  
12.           
13.         System.out.println("\n");  
14.         System.out.println("排序后：");  
15.         for (int i = 0; i < a.length; ++ i){  
16.             System.out.print(a[i] + " ");  
17.         }  
18.     }  
19.       
20.     public static void selectSort(int a[]){  
21.       
22.         int min = 0;  
23.         int temp = 0;  
24.           
25.           
26.         for (int i = 0; i < a.length - 1; ++ i){  
27.           
28.             min = i;  
29.             for (int j = i + 1; j < a.length; ++ j){  
30.                 if (a[min] > a[j]){  
31.                     min = j;  
32.                 }  
33.             }  
34.               
35.             if (min != i){  
36.                 temp = a[min];  
37.                 a[min] = a[i];  
38.                 a[i] = temp;  
39.             }  
40.         }  
41.     }  
42. }  

         执行效果如图：

2.冒泡排序

  冒泡排序的关键点是从后向前对相邻的两个数组元素进行比较，若后面元素的值小于前面元素的值，则将这两个元素交换位置，否则不进行交换。依次进行下去，第一趟排序可将数组中值最小的元素移至下标为0的位置。对于有n个元素的数组，循环执行n-1趟扫描便可完成排序。(当然，也可以从前向后对相邻的两个数组元素进行比较，但此时应注意将大数向后移，与小者前移的冒泡法相对应，可将这种大者后移的排序称为下沉法)。

       下图演示了有6个元素的数组实施冒泡法排序(小数前移)的前两趟比较与交换过程。可以看出，第一趟排序后最小数12已移到了下标为0的正确位置；第二趟排序后次小数17移到了下标为1的正确位置。

 

        代码实现：

[java]  view plain copy

1. public class BubbleSort{  
2.   
3.     public static void main(String[] args){  
4.         int a[] = {1, 23, 45, 6, 0, 99, 100, 89, 34, 56};  
5.           
6.         System.out.println("排序前：");  
7.         for (int i = 0; i < a.length; ++ i)  
8.             System.out.print(a[i] + " ");  
9.               
10.         bubbleSort(a);  
11.           
12.         System.out.println();  
13.         System.out.println("排序后：");  
14.         for (int i = 0; i < a.length; ++ i)  
15.             System.out.print(a[i] + " ");  
16.     }  
17.       
18.     public static void bubbleSort(int a[]){  
19.         int temp  = 0;  
20.           
21.         for (int i = 0; i < a.length - 1; ++ i){  
22.             for (int j = i; j < a.length; ++ j){  
23.               
24.                 if (a[i] > a[j]){  
25.                     temp = a[i];  
26.                     a[i] = a[j];  
27.                     a[j] = temp;  
28.                 }  
29.             }  
30.         }  
31.     }  
32. }  

 

      执行效果如图：

 

3.二分查询

 算法剖析：

二分查找是在一个有序表(数据是按其值由小到大或由大到小依次存放的，这里我们以值由小到大排列为例)中，每次都与中间的那个元素比较，若相等则查找成功；否则，调整查找范围，若中间那个元素的值小于待查值，则在表的后一半中查找；若中间那个元素的值大于待查值，则在表的前一半中查找；如此循环，每次只与一半中的一个元素比较，可使查找效率大大提高。

      

      代码：

 

[java]  view plain copy

1. import java.util.*;  
2.   
3. public class FindSearch{  
4.   
5.     public static void main(String [] args){  
6.           
7.           
8.         int a[] = {2, 4, 7, 18, 25, 34, 56, 68, 89};  
9.         System.out.println("打印原始数据：");  
10.         for (int i = 0; i < a.length; ++ i){  
11.             System.out.print(a[i] + " ");  
12.         }  
13.         System.out.println();  
14.           
15.         System.out.println("请输入要查找的整数：");  
16.         Scanner scan = new Scanner(System.in);  
17.         int num = scan.nextInt();  
18.         int pos = 0;  
19.         pos = binaryFind(a, num);  
20.         if (-1 != pos)  
21.             System.out.println("所查整数在数组中的位置下标是：" + pos);  
22.         else  
23.             System.out.println("没找到待查数据!");  
24.     }  
25.       
26.     public static int binaryFind(int a[],int num){  
27.       
28.         int low, mid, high;  
29.           
30.         low = 0;//low是第一个数组元素的下标  
31.         high = a.length - 1;//high是最后一个数组元素的下标  
32.         mid = (low + high) / 2;//mid是中间那个数组元素的下标  
33.           
34.         while (low <= high){  
35.           
36.             if (num == a[mid]){  
37.                 return  mid;  
38.             }else if (num > a[mid]){  
39.                 low = mid + 1;//要找的数可能在数组的后半部分中  
40.                 mid = (low + high) / 2;  
41.             }else{  
42.                 high = mid - 1;//要找的数可能在数组的前半部分中  
43.                 mid = (low + high) / 2;  
44.             }  
45.         }  
46.           
47.           
48.         //mid是数组元素下标，若为-1则表示不存在要查的元素  
49.         if (mid != ((low + high) / 2))  
50.             return mid;  
51.         else  
52.             return -1;  
53.               
54.     }  
55. }  

      运行效果截图：