排序算法的時間複雜度

選擇排序

命題：
對於長度爲N的數組，選擇排序需要大約N22 次比較和N次交換。

證明：
0到 N−1 的任意i 都會進行一次交換和N−1−i 次比較，因此總共有N次交換以及
(N−1)+(N−2)+...+2+1 =N(N−1)2 ~N22 次比較

/**
 * 選擇排序
 */
public class SelectionSort {

    public static void sort(Comparable[] arr){
        int n = arr.length;
        for(int i=0;i<n;i++){
            int minIndex = i;
            for(int j=i+1;j<n;j++){
                if(Tlt.less(arr[j],arr[minIndex])){
                    minIndex = j;
                }
            }
            Tlt.exch(arr,i,minIndex);
        }
    }

}

插入排序

命題
對於隨機排序的長度爲N且元素不重複的數組，平均情況下插入排序需要~N24 次比較以及~N24 次交換。最壞情況下需要~N22 次比較和N22 次交換，最好情況下需要N−1 次比較和0次交換。

/**
 * 插入排序
 * 特點：可提前終止內循環，對於局部有序數組更有利
 */
public class InsertionSort {

    /**
     * 簡單方式，交換次數較多
     */
    public static void sort(Comparable[] arr){
        int n = arr.length;
        for(int i=1;i<n;i++){
            for(int j=i;j>0;j--){
                if(Tlt.less(arr[j],arr[j-1])){
                    Tlt.exch(arr,j,j-1);
                }else{
                    break;
                }
            }
        }
    }

    /**
     * 優化方式，一個元素只交換一次
     */
    public static void sort2(Comparable[] arr){
        int n = arr.length;

        for(int i=1;i<n;i++){
            Comparable e = arr[i];
            int j;
            for(j=i;j>0 && Tlt.less(e,arr[j-1]);j--){
                // j-1向後移動
                arr[j] = arr[j-1];
            }
            arr[j] = e;
        }
    }

    /**
     * 局部排序
     */
    public static void sort2(Comparable[] arr,int l,int r){
        for(int i=l+1;i<=r;i++){
            Comparable e = arr[i];
            int j;
            for(j=i;j>l && Tlt.less(e,arr[j-1]);j--){
                // j-1向後移動
                arr[j] = arr[j-1];
            }
            arr[j] = e;
        }
    }

    public static void main(String[] args) {
        Integer[] random = Tlt.random(10, 0, 10);
        sort2(random,1,9);
        Tlt.show(random);
    }
}

希爾排序

/**
 * @author fangxin
 * @date 2017/4/1.
 */
public class ShellSort {

    void sort(Integer a[]){
        int h = 1;
        // 遞增序列
        int n = a.length;
        while(h<n/3){
            h = 3*h+1;//1，4，13，40...
        }
        while(h>=1){
            for (int i = h; i < n; i++){
                for (int j = i; j >= h && Tlt.less(a[j],a[j-h]); j -= h){
                    Tlt.exch(a,j, j-h);
                }
            }
            // 按照遞增序列遞減
            h = h/3;
        }

    }

    public static void main(String[] args) {
        Integer[] arr = new Integer[]{49,38,65,97,26,13,27,49,55,4};
        ShellSort shellSort = new ShellSort();
        shellSort.sort(arr);
        Tlt.show(arr);
    }
}

希爾排序時間複雜度分析