快速排序：時間複雜度O（nlogn），不穩定的排序演算法

原理：快速排序是一種交換排序，它的基本思想是：通過一趟排序將待排序的記錄分割成獨立的兩部分，其中一部分記錄的關鍵字均比另一部分記錄的關鍵字小，則可分別對這兩部分記錄繼續進行排序，以達到整個序列有序的目的。快速排序使用分治法來把一個串（list）分為兩個子串（sub-lists）

//快速排序
public class QuickSort{
    
    public static void quickSort(int num[]){
        if(num == null || num.length < 2){//如果陣列為null或者長度小於2直接返回,無需進行快排
            return ;
        }
        quickSort(num, 0, num.length-1);
    }

    //使用遞迴進行快排
    private static void quickSort(int num[], int low, int high){
        int pivot;
        if(low < high){
            pivot = partition(num, low, high);
            quickSort(num, low, pivot-1);
            quickSort(num, pivot+1, high);
        }
    }

    //分治
    private static int partition(int num[], int low, int high){
        int pivotKey = num[low];
        while(low < high){
            while(low < high && num[high] >= pivotKey){
                high--;
            }
            swap(num, low, high);
            while(low < high && num[low] <= pivotKey){
                low++;
            }
            swap(num, low, high);
        }
        return low;
    }
    
    //交換順序
    private static void swap(int num[], int i, int j){
        int tmp = num[i];
        num[i] = num[j];
        nnum[j] = tmp;
    }
}
 

堆排序：時間複雜度O（nlogn），不穩定的排序演算法

原理：堆排序是一種選擇排序，堆排序的基本思想就是，將待排序的序列構造成一個大頂堆。此時，整個序列的最大值就是堆頂的根結點。將它移走（其實就是將其與堆陣列的末尾元素交換，此時末尾元素就是最大值，）然後將剩餘的n-1個序列重新構造成一個堆，這樣就會得到n個元素中的次小值。如此反覆執行，就能得到一個有序序列了。

//堆排序
public class HeapSort{
    
    public static void heapSort(int num[]){
        if(num == null || num.length < 2){//如果num為null或者長度小於2，無需進行堆排
            return;
        }
        for(int i = 0; i < num.lengh; i++){
            heapInsert(num, i);//調整為大頂堆,從下往上調
        }
        int size = num.length;
        swap(num, 0, --size);
        while(size > 0){
            heapify(num, 0, size);//調整為大頂堆,從上往下調
            swap(num, 0, --size);
        }
    }

    //從下往上調整為大頂堆
    private static void heapInsert(int num[], int i){
        while(num[i] > num[(i-1)/2]){
            swap(num, i, (i-1)/2);
            i = (i-1)/2;
        }
    }
    
    //從上往下調整為大頂堆
    private static void heapify(int num[], int i, int size){
        int left = 2 * i + 1;
        while(left + 1 < size){
            int large = left + 1 < size && num[left] > num[left+1] ? left : left+1;
            large = left + 1 < size && num[large] > num[i] ? large : i;
            if(large == i){
                break;
            }
            swap(num, i, large);
            i = large;
            left = 2 * i + 1;
        }
    }

    //陣列元素交換
    private static void swap(int num[], int i, int j){
        int tmp = num[i];
        num[i] = num[j];
        num[j] = tmp;
    }
}
 

氣泡排序：時間複雜度O（n^2），穩定的排序演算法

原理：氣泡排序是一種交換排序，它的基本思想是：兩兩比較相鄰記錄的關鍵字，如果反序則交換，直到沒有反序的記錄為止。

//氣泡排序
public class BubbleSort{

    public static void bubbleSort(int num[]){
        if(num == null || num.length < 2){//陣列為null或者長度小於2,無需排序直接輸出
            return;
        }

        for(int i = 0; i < num.length-1; i++){
            for(int j = 0; j < num.length - i - 1; j++){
                if(num[j] > num[j+1]){
                    int tmp = num[j];
                    num[j] = num[j+1];
                    num[j+1] = tmp;
                }
            }
        }
    }
}
 

簡單選擇排序：時間複雜度O（n^2），穩定的排序演算法。

原理：簡單選擇排序是選擇排序的一種，簡單選擇排序就是通過n-i次關鍵字間的比較，從n-i+1個記錄中選出關鍵字最小的記錄，並和第i（1<=i<=n）個記錄交換之。

//簡單選擇排序
public class SimpleSort{
    
    public static void simpleSort(int num[]){
        if(num == null || num.length < 2){//如果num為null或者長度小於2直接返回
            return;
        }
        for(int i = 0; i < num.length-1; i++){
            int min = i;
            for(int j = i + 1; j < num.length; j++){ //每一輪從第i個元素開始找出最小的元素
                if(num[j] < num[min]){
                    min = j; 
                }
            }
            swap(num, i, min);//找出從第i個元素後的最小元素與第i個元素進行交換
        }
    }   
    
    //交換陣列元素的位置
    public static void swap(int num[], int i, int j){
        int tmp = num[i];
        num[i] = num[j];
        num[j] = tmp;
    }

}

直接插入排序：時間複雜度O（n^2），穩定的排序演算法。

原理：直接插入排序是插入排序的一種，它的基本思想就是將一個記錄插入到已經排好序的有序表中，從而得到一個新的、記錄數增1的有序表。

//直接插入排序
public class StraightInsertSort{
    
    public static void straightInsertSort(int num[]){
        if(num == null || num.length < 2){
            return ;
        }
        for(int i = 1; i < num.length; i++){
            int ins = num[i];
            int j = i;
            for(j = i; j > 0 && num[j-1] > ins; j--){
                num[j] = num[j-1];
            }
            num[i] = ins;
        }
    }
}

歸併排序：時間複雜度O(nlogn)，穩定的排序演算法

原理：二路歸併排序是歸併排序中較為經典的一種，它是利用歸併的思想實現的排序演算法。二路歸併排序假設初始序列含有n個記錄，則可以看成是n個有序的子序列，每個子序列的長度為1，然後兩兩歸併，……，如此重複，直至得到一個長度為n的有序序列為止，這種排序方法稱為2路歸併排序。

//歸併排序
public class MergeSort{
    
    public static void mergeSort(int num[]){
        if(num == null || num.length < 2){
            return;
        }
        mergeSort(num, 0, num.length-1);
    }
    
    //利用遞迴進行歸併排序
    private static void mergeSort(int num[], int low, int high){
        if(low < high){
            int mid = (low+high)/2
            mergeSort(num, low, mid);
            mergeSort(num, mid+1, high);
            merge(num, low, mid, high);
        }
    }

    //歸併
    private static void merge(int num[], int low, int mid, int high){
        int tmp[] = new int[high-low+1];//開闢臨時陣列用來儲存排好序的元素
        int i = low; //定義左指標,指向陣列左邊部分
        int j = mid + 1; //定義右指標,指向陣列右邊部分
        int k = 0;
        while(i <= mid && j <= high){
            if(num[i] < num[j]){
                tmp[k++] = num[i++];
            }else{
                tmp[k++] = num[j++];
            }
        }
        while(i <= mid){ //左邊部分有剩餘，直接放到tmp陣列末尾
            tmp[k++] = num[i++];
        }
        while(j <= high){ //右邊部分有剩餘，直接放到tmp陣列末尾
            tmp[k++] = num[j++];
        }
        
        for(int x = 0; x < tmp.length; x++){//對原陣列進行覆蓋
            num[x+low] = tmp[x]; //注意角標問題
        }
    }
}

希爾排序：時間複雜度O（nlogn），不穩定的排序演算法

原理：希爾排序是直接插入排序的改進版本，與直接插入排序不同的是它會優先比較距離較遠的元素，希爾排序又叫縮小增量排序。

//希爾排序
public class ShellSort{
    
    public static void shellSort(int num[]){
        if(num == null || num.length < 2){
            return;
        }
        int len = num.length;
        int add = len;
        while(true){
            add = add / 3 + 1;
            for(int i = 0; i < add; i++){
                for(int j = i + add; j < len; j = j + add){
                    int current = num[j];
                    int k;
                    for(int k = j - add; k >= 0 && num[k] > current; k = k - add){
                        num[k+add] = num[k];
                    }
                    num[k+add] = current;
                }
            }
            if(add == 1){
                break;
            }
        }
    }
}