Java实例2 - 冒泡排序 Bubble Sort

[java] view plaincopy

1. /** 
2.  * 冒泡排序估计是每本算法书籍都会提到的排序方法。 
3.  * 它的基本思路是对长度为N的序列，用N趟来将其排成有序序列。 
4.  * 第1趟将最大的元素排在序列尾部，第2趟将第2大的元素排在倒数第二的位置， 
5.  * 即每次把未排好的最大元素冒泡到序列最后端。  
6.  * 该排序方法实际上分为两重循环，外层循环：待排元素从数组的第1个元素开始。 
7.  *  内层循环：待排元素从数组的第1个元素开始，直到数组尾端未排过的元素。 
8.  *  在内循环中，如果遇到前面元素比其后的元素大就交换这两个元素的位置。 
9.  *  由此可见冒泡排序的复杂度是O(n^2) 
10.  */  
11. package al;  
12. public class BubbleSort {  
13.     /* 
14.      * 冒泡排序 Java语言编写，可以直接运行 输入：n个数<a1,a2,,an> 
15.      * 输出：输入序列的一个排列<a1',a2',,an'>,其中a1'<=a2'<=<=an' 待排的数也称为key 复杂度：O(n^2) 输出结果：9 
16.      * 10 14 14 21 43 50 77 例子：高矮个站队 
17.      */  
18.     public static void main(String[] args) {  
19.         BubbleSort bubbleSort = new BubbleSort();  
20.         int[] elements = { 14, 77, 21, 9, 10, 50, 43, 14 };  
21.         // sort the array  
22.         bubbleSort.sort(elements);  
23.         // print the sorted array  
24.         for (int i = 0; i < elements.length; i++) {  
25.             System.out.print(elements[i]);  
26.             System.out.print(" ");  
27.         }  
28.     }  
29.     /** 
30.      * @author 
31.      * @param array 
32.      *            待排数组 
33.      * @return void 
34.      */  
35.     public void sort(int[] array) {  
36.         int i, j;  
37.         int tmp;  
38.         for (i = 0; i <= (array.length - 1); i++) { // outer loop  
39.             for (j = 0; j < (array.length - 1 - i); j++) { // inner loop  
40.                 if (array[j] > array[j + 1]) {  
41.                     tmp = array[j];  
42.                     array[j] = array[j + 1];  
43.                     array[j + 1] = tmp;  
44.                 }  
45.             }  
46.         }  
47.     }  
48. }