1. 程式人生 > >經典排序算法--冒泡排序

經典排序算法--冒泡排序

數據 i++ 當前 數組排序 exchange 元素 cti print oid

冒泡排序的基本思想:

在要排序的一組數中,對當前還未排好序的範圍內的全部數,自上而下對相鄰的兩個數依次進行比較和調整,讓較大 的數往下沈 ,較小的往上冒。即:每當兩相鄰的數比較後發現它們的排序與排序要求相反時,就將它們互換。

關於程序中4中冒泡排序寫法的說明:

bubble_sort1:基本的冒泡排序的寫法。

bubble_sort2:基本冒泡排序的不同寫法,基本的冒泡排序是每次遍歷,每次縮小範圍1,這種辦法是每次正向和反向遍歷,每次縮小範圍2,所以兩者的比較次數也是一樣的。

bubble_sort3:如果在某一趟的冒泡途中沒有出現數據交換,那就只能是數據已經被排好序了,這樣就可以提前得知數據排好序從而中斷循環,消除掉不必要的比較。

bubble_sort4:如果在某一趟的冒泡途中最後的交換出現在pos的位置,那麽表示pos位置以後都已經排好序,這樣相比於基本冒泡每一次縮小遍歷範圍1而言有可能一次縮小的遍歷範圍>=1,所以這樣也可以提高排序的效率。

程序代碼如下:

  1 package mecrt.study.collection.sort;
  2 
  3 /**
  4  * 冒泡排序
  5  */
  6 public class BubbleSort {
  7     public static void main(String[] args) {
  8 
  9         int[] a = {3,5,1,2,4,9,6,8,10,7};
10 int[] b = {3,5,1,2,4,9,6,8,10,7}; 11 int[] c = {3,5,1,2,4,9,6,8,10,7}; 12 int[] d = {3,5,1,2,4,9,6,8,10,7}; 13 System.out.println("\n初始值:"); 14 print(a); 15 int count1 = dubbleSort1(a); 16 System.out.println("排序後:"); 17 print(a);
18 System.out.println("dubbleSort1比較次數"+count1); 19 20 21 System.out.println("\n初始值:"); 22 print(b); 23 int count2 = dubbleSort2(b); 24 System.out.println("排序後:"); 25 print(b); 26 System.out.println("dubbleSort2比較次數"+count2); 27 28 System.out.println("\n初始值:"); 29 print(c); 30 int count3 = dubbleSort3(c); 31 System.out.println("排序後:"); 32 print(c); 33 System.out.println("dubbleSort3比較次數"+count3); 34 35 System.out.println("\n初始值:"); 36 print(d); 37 int count4 = dubbleSort4(d); 38 System.out.println("排序後:"); 39 print(d); 40 System.out.println("dubbleSort4比較次數"+count4); 41 } 42 43 /** 44 * 最基本的冒泡排序 45 * @param data 46 */ 47 public static int dubbleSort1(int[] data){ 48 int count = 0; 49 //冒泡一次放好一個數,冒泡data.length-1次,數組排序完成 50 for (int i = 0; i < data.length-1; i++) { 51 //後面i個數已經冒泡完成,為有序數列,不需要再次進行冒泡 52 for (int j = 0; j < data.length-1-i; j++,count++) { 53 //相鄰元素想比較,進行冒泡 54 if(data[j]>data[j+1]){ 55 swap(data, j, j+1); 56 } 57 } 58 } 59 return count; 60 } 61 62 /** 63 * 雙向冒泡排序 64 * @param data 65 */ 66 public static int dubbleSort2(int[] data){ 67 int low = 0; 68 int high = data.length-1; 69 int j,count=0; 70 while(low<high){ 71 for (j=low; j < high; j++, count++) { 72 if(data[j]>data[j+1]){ 73 swap(data, j, j+1); 74 } 75 } 76 high--; 77 for (j = high; j > low; j--,count++) { 78 if(data[j]<data[j-1]){ 79 swap(data, j, j-1); 80 } 81 } 82 low++; 83 } 84 return count; 85 } 86 87 /** 88 * 冒泡排序,如果在某一趟的冒泡途中沒有出現數據交換, 89 * 那就只能是數據已經被排好序了, 90 * 這樣就可以提前得知數據排好序從而中斷循環, 91 * 消除掉不必要的比較。 92 * @param data 93 * @return 94 */ 95 public static int dubbleSort3(int[] data){ 96 int i,j,count = 0; 97 boolean exchange = true; 98 for (i = 0; i < data.length-1&&exchange; i++) { 99 for (j = 0,exchange = false; j < data.length-1-i; j++,count++) { 100 if(data[j]>data[j+1]){ 101 swap(data, j, j+1); 102 exchange = true; 103 } 104 } 105 } 106 return count; 107 } 108 109 /** 110 * 如果在某一趟的冒泡途中最後的交換出現在pos的位置, 111 * 那麽表示pos位置以後都已經排好序, 112 * 這樣相比於基本冒泡每一次縮小遍歷範圍1而言有可能一次縮小的遍歷範圍>=1, 113 * 所以這樣也可以提高排序的效率。 114 * @param data 115 * @return 116 */ 117 public static int dubbleSort4(int[] data){ 118 int i,j,pos = 0,count = 0; 119 for (i = 0; i < data.length-1; i = data.length - 1 - pos) { 120 for (j = 0,pos = 0; j < data.length-1-i; j++,count++) { 121 if(data[j]>data[j+1]){ 122 swap(data, j, j+1); 123 pos = j+1; 124 } 125 } 126 } 127 return count; 128 } 129 public static void swap(int[] data,int i,int j){ 130 if(i == j ){ 131 return ; 132 } 133 data[i] = data[i] + data[j]; 134 data[j] = data[i] - data[j]; 135 data[i] = data[i] - data[j]; 136 } 137 138 private static void print(int[] a){ 139 for (int i = 0; i < a.length; i++) { 140 System.out.print(a[i]+" "); 141 } 142 System.out.println(); 143 } 144 }

運行結果:

初始值:
3  5  1  2  4  9  6  8  10  7  
排序後:
1  2  3  4  5  6  7  8  9  10  
dubbleSort1比較次數45

初始值:
3  5  1  2  4  9  6  8  10  7  
排序後:
1  2  3  4  5  6  7  8  9  10  
dubbleSort2比較次數45

初始值:
3  5  1  2  4  9  6  8  10  7  
排序後:
1  2  3  4  5  6  7  8  9  10  
dubbleSort3比較次數30

初始值:
3  5  1  2  4  9  6  8  10  7  
排序後:
1  2  3  4  5  6  7  8  9  10  
dubbleSort4比較次數33

冒泡排序法的特點:

時間復雜度:O(n^2)

空間復雜度:O(1)

穩定性:穩定

經典排序算法--冒泡排序