冒泡排序（Bubble Sort），它重復地走訪過要排序的元素，依次比較相鄰兩個元素，如果他們的順序錯誤就把他們調換過來，直到沒有元素再需要交換，

排序完成。這個算法的名字由來是因為越小(或越大)的元素會經由交換慢慢“浮”到數列的頂端

冒泡排序算法的運作如下：

• 比較相鄰的元素，如果前一個比後一個大，就把它們兩個調換位置
• 對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最後一對。這步做完後，最後的元素會是最大的數
• 針對所有的元素重復以上的步驟，除了最後一個
• 持續每次對越來越少的元素重復上面的步驟，直到沒有任何一對數字需要比較

代碼實例 要排序的數組：int[] arr={25,18,21,9};

• 排序前的數組為:25 18 21 9
• 第1趟第1次排序後數組的順序:18 25 21 9
• 第1趟第2次排序後數組的順序:18 21 25 9
• 第1趟第3次排序後數組的順序:18 21 9 25
• 第1趟排序後數組的順序:18 21 9 25
• 第2趟第1次排序後數組的順序:18 21 9 25
• 第2趟第2次排序後數組的順序:18 9 21 25
• 第2趟排序後數組的順序:18 9 21 25
• 第3趟第1次排序後數組的順序:9 18 21 25
• 第3趟排序後數組的順序:9 18 21 25
• 排序後的數組為:9 18 21 25

冒泡排序的優點：每進行一趟排序，就會少比較一次，因為每進行一趟排序都會找出一個較大值

用時間復雜度來說：

　　1.如果我們的數據正序，只需要走一趟即可完成排序。所需的比較次數C和記錄移動次數M均達到最小值，即：C_min=n-1;M_min=0;所以，冒泡排序最好的時間復雜度為O_(n)。

 2.如果很不幸我們的數據是反序的，則需要進行n-1趟排序。每趟排序要進行n-i次比較(1≤i≤n-1)，且每次比較都必須移動記錄三次來達到交換記錄位置。在這種情況下，比較和移動次數均達到最大值：

冒泡排序的最壞時間復雜度為：O_(n²) 。

綜上所述：冒泡排序總的平均時間復雜度為：O_(n²)

package com.yyx.sortingAlgorithm;
/**
 * 冒泡排序
 * yyx 2018年2月3日
 */
public class BubbleSort {
    public static void main(String[] args) {
        int temp;
        int[] arr={25,18,21,9}; 
        System.out.print("排序前的數組為:");
        for(int num:arr){
            System.out.print(num+" ");
        }
        for(int i=0;i<arr.length-1;i++){
            for(int j=0;j<arr.length-i-1;j++){
                if(arr[j]>arr[j+1]){
                    temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
                System.out.println();
                System.out.print("第"+(i+1)+"趟第"+(j+1)+"次排序後數組的順序:");
                for(int num:arr){
                    System.out.print(num+" ");
                }
            }
            System.out.println();
            System.out.print("第"+(i+1)+"趟排序後數組的順序:");
            for(int num:arr){
                System.out.print(num+" ");
            }
            System.out.println();
        }
        System.out.println();
        System.out.print("排序後的數組為:");
        for(int num:arr){
            System.out.print(num+" ");
        }
    }
}

優化

對冒泡排序常見的改進方法是加入標誌性變量exchange，用於標誌某一趟排序過程中是否有數據交換。如果進行某一趟排序時並沒有進行數據交換，

則說明所有數據已經有序，可立即結束排序，避免不必要的比較過程

package com.yyx.sortingAlgorithm;

/**
 * 冒泡排序:它重復地走訪過要排序的數列，一次比較兩個元素，如果他們的順序錯誤就把他們交換過來。
 *        走訪數列的工作是重復地進行直到沒有再需要交換，也就是說該數列已經排序完成
 * yyx 2018年2月3日
 */
public class BubbleSort {
    public static void main(String[] args) {
        int temp;
        boolean bChange = false;
        int[] arr = { 25, 18, 21, 9 };
        //循環的趟數
        for (int i = 0; i < arr.length - 1; i++) {
            //每趟循環比較的次數
            for (int j = 0; j < arr.length - i - 1; j++) {
                // 比較相鄰的元素，如果前面的數大於後面的數，則交換
                if (arr[j] > arr[j + 1]) {
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    bChange = true;
                }
            }
            // bChange==false表示沒有交換
            if (bChange == false) {
                break;
            }
        }
        System.out.print("排序後的數組為:");
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

排序算法冒泡排序