基本思想

冒泡排序簡單來說就是每一趟排序比較相鄰兩個元素值，大的交換到后面，那么一趟排序下來最大的元素被沉到最后。對剩下的元素重復以上操作，每一趟都將最大的元素沉到最后，直到所有元素有序。

代碼實現

public void bubbleSort(int[] a){
        int temp;
        for(int i = 0; i < a.length - 1; i++){
            for(int j = 0; j < a.length - 1 - i; j++){
                if(a[j] > a[j + 1]){
                    temp = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = temp;
                }
            }
        }
    }

時間復雜度

• 最好情況：O(n)，若待排序序列全部有序，則只需進行一趟比較，若沒有元素交換則結束排序。
• 平均情況：O(n*n)

算法改進

1. 前面我們說到，冒泡排序在最好的情況下時間復雜度是O(n)，但事實上前面貼的代碼在元素全部有序的情況下時間復雜度依然是O(n*n)，因為一趟排序下來我們并不知道這趟排序元素有沒有交換。因此，我們需要添加一個標記位來標記一趟排序元素是否有交換。

public void bubbleSort(int[] a){
        int temp;
        boolean flag;
        for(int i = 0; i < a.length - 1; i++){
            flag = false;
            for(int j = 0; j < a.length - 1 - i; j++){
                if(a[j] > a[j + 1]){
                    temp = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = temp;
                    flag = true;
                }
            }
            if(flag == false){
                break;
            }
        }
    }

2. 再做進一步的優化。如果有100個數的數組，僅前面10個無序，后面90個都已排好序且都大于前面10個數字，那么在第一趟遍歷后，最后發生交換的位置必定小于10，且這個位置之后的數據必定已經有序了，記錄下這位置，第二次只要從數組頭部遍歷到這個位置就可以了。

public void bubbleSort(int[] a){
        int temp;
        int lastSwapPos = a.length - 1;
        int lastSwapPosTemp;
        for(int i = 0; i < a.length - 1; i++){
            lastSwapPosTemp = lastSwapPos;
            for(int j = 0; j < lastSwapPosTemp; j++){
                if(a[j] > a[j + 1]){
                    temp = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = temp;
                    lastSwapPos = j;
                }
            }
            if(lastSwapPosTemp == lastSwapPos){
                break;
            }
        }
    }