O（n^2）的排序算法--希爾，插排，選排，冒泡

選擇排序法

public class SelectionSort{

    //爲了不產生實例
    private 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(arr[minIndex].compareTo(arr[j])>0){
                    minIndex = j;//只是爲了得出數組中最小值的索引
                }
            }
              //交換值
            swap(arr,minIndex,j);
        }
    }
    //交換
    private static void swap(Object[] arr,int index1,int index2){
        Object o = arr[index1];
        arr[index1] = arr[index2];
        arr[index2] = o;
    }
}

寫法1

public class BubbleSort {
    // 我們的算法類不允許產生任何實例
    private BubbleSort(){}

    public static void sort(Comparable[] arr){

        int n = arr.length;
        boolean swapped = false;

        do{
            swapped = false;
            for( int i = 1 ; i < n ; i ++ )
                if( arr[i-1].compareTo(arr[i]) > 0 ){
                    swap( arr , i-1 , i );
                    swapped = true;
                }

            // 優化, 每一趟Bubble Sort都將最大的元素放在了最後的位置
            // 所以下一次排序, 最後的元素可以不再考慮
            n --;
        }while(swapped);
    }

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

改進寫法

public class BubbleSort2 {

    // 我們的算法類不允許產生任何實例
    private BubbleSort2(){}

    public static void sort(Comparable[] arr){

        int n = arr.length;
        int newn; // 使用newn進行優化

        do{
            newn = 0;
            for( int i = 1 ; i < n ; i ++ )
                if( arr[i-1].compareTo(arr[i]) > 0 ){
                    swap( arr , i-1 , i );

                    // 記錄最後一次的交換位置,在此之後的元素在下一輪掃描中均不考慮
                    newn = i;
                }
            n = newn;
        }while(newn > 0);
    }

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

插入排序法 Insertion Sort

public class InsertionSort{
    private InsertionSort(){}

    public static void sort(Comparable[] arr){
        int n = arr.length;
        for(int i = 0; i < n ; i++){

            //寫法 1，易懂，但是不簡潔,可以改進
            /*
            for(int j = i;j > 0 ; j--){
                if(arr[j].compareTo(arr[j-1]) < 0 ){
                    swap(arr,j,j-1);
                }else{
                    break;
                }
            }
            */

            //寫法2 ,只是在1的基礎上改進了寫法，但是沒有優化算法
            /*
            for(int j = i; j > 0 && arr[j].compareTo(arr[j-1])<0;j--){
                swap(arr,j,j-1);
            }
            */

            //寫法3，上面的寫法，交換swap次數太多，所以會消耗太多性能，改進
            Comparable comparable = arr[i];
            int j = i;
            for(;j > 0 && arr[j-1].compareTo(comparable)>0 ;j--){
                arr[j] = arr[j-1];
            }
            arr[j] = comparable;//甚至可以不用寫swap
        }
    }

    private static void swap(Object[] arr,int index1, int index2){
        Object object = arr[index1];
        arr[index1] = arr[index2];
        arr[index2] = object;
    }

}

希爾排序 ShellSort

• 希爾排序就是在InsertionSort改進而來的。只是設置了交換步長，當步長逐漸縮小唯一的時候，就InsertionSort，只是此時，該數列基本有序，此時插入排序的性能十分優異。
• 時間複雜度O(n^1.5)

public class ShellSort{
    private ShellSort() {
    }

    public static void sort(Comparable[] arr){
        int n = arr.lenght;
        //設置變化步長
        // 計算 increment sequence: 1, 4, 13, 40, 121, 364, 1093...

        int h = 1;
        while(h < n/3) h = h*3+1；

        while(h >= 1){
            for(int i = h ; i < n ; i++){
                Comparable comparable = arr[i];

                int j = i;
                for(;j>=h && comparable.compareTo(arr[j-h])<0;j -= h){
                     arr[j] = arr[j - h];
                }
                arr[j] = comparable;
            }
            h /= 3;
        }
    }
}