冒泡排序

代碼示例

    public  static <E extends Comparable<E>> void sort(E[] data){
        //最后一個不需要遍歷到
        for (int i = 0; i < data.length - 1; i++) {
            //arr[n-i, n) 已經排好
            //通過冒泡早arr[n-i-1] 位置放上合適的元素
            for (int j = 0; j < data.length - 1 - i; j++) {
                if (data[j].compareTo(data[j + 1]) > 0 )
                    swap(data,j, j +1);
            }
        }
    }

    //優化1 如果數組是有序數組
    public  static <E extends Comparable<E>> void sort2(E[] data){
        //最后一個不需要遍歷到
        for (int i = 0; i < data.length - 1; i++) {
            //arr[n-i, n) 已經排好
            //通過冒泡早arr[n-i-1] 位置放上合適的元素
            boolean isSwaped = false; //有序數組 不進行交換
            for (int j = 0; j < data.length - 1 - i; j++) {
                if (data[j].compareTo(data[j + 1]) > 0 ){
                    swap(data,j, j +1);
                    isSwaped = true;
                }
            }
            if (!isSwaped) break;
        }
    }

    //優化2 減少循環輪數 記錄在當前輪中最后一次執行swap時j的值  表示data.length - lastSwappedIndex 已經排好序了
    public  static <E extends Comparable<E>> void sort3(E[] data){

        //最后一個不需要遍歷到
        for (int i = 0; i < data.length - 1;) {

            //arr[n-i, n) 已經排好
            //通過冒泡早arr[n-i-1] 位置放上合適的元素

           int lastSwappedIndex = 0;

            for (int j = 0; j < data.length - 1 - i; j++) {
                if (data[j].compareTo(data[j + 1]) > 0 ){
                    swap(data,j, j +1);
                    lastSwappedIndex = j + 1;
                }
            }
            //表示 有幾個元素已經排好序了 不用重新循環
            i = data.length - lastSwappedIndex;
        }
    }

    private static <E>  void swap(E[] arr, int i, int j){
        E t = arr[i];
        arr[i] = arr[j];
        arr[j] = t;
    }

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

穩定性

排序前相等的倆個元素，排序后相對位置不變。
冒泡排序法是穩定的，每次只比較相鄰元素，相同大小的元素沒有機會跳躍。