一、概念

1、內部排序與外排序

內部排序：待排序記錄存放在計算機隨機儲存器中（說簡單點，就是記憶體）進行的排序過程，接下來講的十大演算法都是內部排序。 外部排序：待排序記錄的數量很大，以致於記憶體不能一次容納全部記錄，所以在排序過程中需要對外存進行訪問的排序過程。

2、非線性時間比較類排序與線性時間非比較類排序

**非線性時間比較類排序：**通過比較來決定元素間的相對次序，由於其時間複雜度不能突破O(nlogn)，因此稱為非線性時間比較類排序。

**線性時間非比較類排序：**不通過比較來決定元素間的相對次序，它可以突破基於比較排序的時間下界，以線性時間執行，因此稱為線性時間非比較類排序。

在比較類排序中，歸併排序號稱最快，其次是快速排序和堆排序，兩者不相伯仲，但是有一點需要注意，資料初始排序狀態對堆排序不會產生太大的影響，而快速排序卻恰恰相反。

線性時間非比較類排序一般要優於非線性時間比較類排序，但前者對待排序元素的要求較為嚴格，比如計數排序要求待排序數的最大值不能太大，桶排序要求元素按照hash分桶後桶內元素的數量要均勻。線性時間非比較類排序的典型特點是以空間換時間。

3、演算法複雜度

**時間複雜度：**一個演算法執行所耗費的時間，從理論上是不能算出來的，必須上機執行測試才能知道。但我們不可能也沒有必要對每個演算法都上機測試，只需知道哪個演算法花費的時間多，哪個演算法花費的時間少就可以了。並且一個演算法花費的時間與演算法中語句的執行次數成正比例，哪個演算法中語句執行次數多，它花費時間就多。一個演算法中的語句執行次數稱為語句頻度或時間頻度。記為T(n)。演算法的時間複雜度是指執行演算法所需要的計算工作量。 n稱為問題的規模，當n不斷變化時，時間頻度T(n)也會不斷變化。但有時我們想知道它變化時呈現什麼規律。為此，我們引入時間複雜度概念。

**空間複雜度：**與時間複雜度類似，空間複雜度是指演算法在計算機內執行時所需儲存空間的度量。

4、演算法穩定性

**穩定：**如果a原本在b前面，而a=b，排序之後a仍然在b的前面。 **不穩定：**如果a原本在b的前面，而a=b，排序之後 a 可能會出現在 b 的後面。

二、演算法原理及實現

1、氣泡排序（Bubble Sort）

氣泡排序是一種簡單的排序演算法。它重複地走訪過要排序的數列，一次比較兩個元素，如果它們的順序錯誤就把它們交換過來。走訪數列的工作是重複地進行直到沒有再需要交換，也就是說該數列已經排序完成。這個演算法的名字由來是因為越小的元素會經由交換慢慢“浮”到數列的頂端。

1.1 演算法描述

• 比較相鄰的元素。如果第一個比第二個大，就交換它們兩個；
• 對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最後一對，這樣在最後的元素應該會是最大的數；
• 針對所有的元素重複以上的步驟，除了最後一個；
• 重複步驟1~3，直到排序完成。

1.2 動圖演示

1.3 程式碼實現

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

2、選擇排序（Selection Sort）

選擇排序(Selection-sort)是一種簡單直觀的排序演算法。它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然後，再從剩餘未排序元素中繼續尋找最小（大）元素，然後放到已排序序列的末尾。以此類推，直到所有元素均排序完畢。

2.1 演算法描述

n個記錄的直接選擇排序可經過n-1趟直接選擇排序得到有序結果。具體演算法描述如下：

• 初始狀態：無序區為R[1…n]，有序區為空；
• 第i趟排序(i=1,2,3…n-1)開始時，當前有序區和無序區分別為R[1…i-1]和R(i…n）。該趟排序從當前無序區中-選出關鍵字最小的記錄R[k]，將它與無序區的第1個記錄R交換，使R[1…i]和R[i+1…n)分別變為記錄個數增加1個的新有序區和記錄個數減少1個的新無序區；
• n-1趟結束，陣列有序化了。

2.2 動圖演示

2.3 程式碼實現

public static void selectionSort(int data[]){
        int minIndex,temp;
        for(int i=0;i<data.length-1;i++){
            minIndex=i;
            for (int j=i+1;j<data.length;j++){
                if(data[j]<data[minIndex]){    //尋找最小的數
                    minIndex=j;                //將最小數的索引儲存
                }
            }
            temp=data[i];
            data[i]=data[minIndex];
            data[minIndex]=temp;
        }
    }

2.4 演算法分析

表現最穩定的排序演算法之一，因為無論什麼資料進去都是O(n2)的時間複雜度，所以用到它的時候，資料規模越小越好。唯一的好處可能就是不佔用額外的記憶體空間了吧。理論上講，選擇排序可能也是平時排序一般人想到的最多的排序方法了吧。

3、插入排序（Insertion Sort）

插入排序（Insertion-Sort）的演算法描述是一種簡單直觀的排序演算法。它的工作原理是通過構建有序序列，對於未排序資料，在已排序序列中從後向前掃描，找到相應位置並插入。

3.1 演算法描述

一般來說，插入排序都採用in-place在陣列上實現。具體演算法描述如下：

• 從第一個元素開始，該元素可以認為已經被排序；
• 取出下一個元素，在已經排序的元素序列中從後向前掃描；
• 如果該元素（已排序）大於新元素，將該元素移到下一位置；
• 重複步驟3，直到找到已排序的元素小於或者等於新元素的位置；
• 將新元素插入到該位置後；
• 重複步驟2~5。

3.2 動圖演示

3.2 程式碼實現

public static void insertionSort(int data[]){
        int preIndex,current;
        for(int i=1;i<data.length;i++){
            preIndex=i-1;
            current=data[i];
            for(;preIndex >= 0 && data[preIndex] > current;preIndex--){
                data[preIndex+1]=data[preIndex];
            }
            data[preIndex+1]=current;
        }
    }

3.4 演算法分析

插入排序在實現上，通常採用in-place排序（即只需用到O(1)的額外空間的排序），因而在從後向前掃描過程中，需要反覆把已排序元素逐步向後挪位，為最新元素提供插入空間。

4、希爾排序（Shell Sort）

1959年Shell發明，第一個突破O(n2)的排序演算法，是簡單插入排序的改進版。它與插入排序的不同之處在於，它會優先比較距離較遠的元素。希爾排序又叫縮小增量排序。

4.1 演算法描述

先將整個待排序的記錄序列分割成為若干子序列分別進行直接插入排序，具體演算法描述：

• 選擇一個增量序列t1，t2，…，tk，其中ti>tj，tk=1；
• 按增量序列個數k，對序列進行k 趟排序；
• 每趟排序，根據對應的增量ti，將待排序列分割成若干長度為m 的子序列，分別對各子表進行直接插入排序。僅增量因子為1時，整個序列作為一個表來處理，表長度即為整個序列的長度。

4.2 動圖演示

4.3 程式碼實現

public static void shellSort(int data[]){
        if(data == null || data.length <= 1){
            return;
        }
        //增量
        int incrementNum = data.length/2;
        while(incrementNum >=1){
            for(int i=0;i<data.length;i++){
                //進行插入排序
                for(int j=i;j<data.length-incrementNum;j=j+incrementNum){
                    if(data[j]>data[j+incrementNum]){
                        int temple = data[j];
                        data[j] = data[j+incrementNum];
                        data[j+incrementNum] = temple;
                    }
                }
            }
            //設定新的增量
            incrementNum = incrementNum/2;
        }
    }

4.4 演算法分析

希爾排序的核心在於間隔序列的設定。既可以提前設定好間隔序列，也可以動態的定義間隔序列。動態定義間隔序列的演算法是《演算法（第4版）》的合著者Robert Sedgewick提出的。

5、歸併排序（Merge Sort）

歸併排序是建立在歸併操作上的一種有效的排序演算法。該演算法是採用分治法（Divide and Conquer）的一個非常典型的應用。將已有序的子序列合併，得到完全有序的序列；即先使每個子序列有序，再使子序列段間有序。若將兩個有序表合併成一個有序表，稱為2-路歸併。

5.1 演算法描述

• 把長度為n的輸入序列分成兩個長度為n/2的子序列；
• 對這兩個子序列分別採用歸併排序；
• 將兩個排序好的子序列合併成一個最終的排序序列。

5.2 動圖演示

5.3 程式碼實現

private static void sort(int[] array, int start, int end) {
        if (start >= end)
            return;

        int mid = (start + end) / 2;
        // 遞迴實現歸併排序
        sort(array, start, mid);
        sort(array, mid + 1, end);
        mergerSort(array, start, mid, end);
    }

    // 將兩個有序序列歸併為一個有序序列(二路歸併)
    private static void mergerSort(int[] array, int start, int mid, int end) {
        int[] arr = new int[end + 1]; // 定義一個臨時陣列，用來儲存排序後的結果
        int low = start; // 臨時陣列的索引
        int left = start;

        int center = mid + 1;
        // 取出最小值放入臨時陣列中
        while (start <= mid && center <= end) {
            arr[low++] = array[start] > array[center] ? array[center++] : array[start++];
        }

        // 若還有段序列不為空，則將其加入臨時陣列末尾

        while (start <= mid) {
            arr[low++] = array[start++];
        }
        while (center <= end) {
            arr[low++] = array[center++];
        }

        // 將臨時陣列中的值copy到原陣列中
        for (int i = left; i <= end; i++) {
            array[i] = arr[i];
        }
    }

5.4 演算法分析

歸併排序是一種穩定的排序方法。和選擇排序一樣，歸併排序的效能不受輸入資料的影響，但表現比選擇排序好的多，因為始終都是O(nlogn）的時間複雜度。代價是需要額外的記憶體空間。

6、快速排序（Quick Sort）

快速排序的基本思想：通過一趟排序將待排記錄分隔成獨立的兩部分，其中一部分記錄的關鍵字均比另一部分的關鍵字小，則可分別對這兩部分記錄繼續進行排序，以達到整個序列有序。

6.1 演算法描述

快速排序使用分治法來把一個串（list）分為兩個子串（sub-lists）。具體演算法描述如下：

• 從數列中挑出一個元素，稱為 “基準”（pivot）；
• 重新排序數列，所有元素比基準值小的擺放在基準前面，所有元素比基準值大的擺在基準的後面（相同的數可以到任一邊）。在這個分割槽退出之後，該基準就處於數列的中間位置。這個稱為分割槽（partition）操作；
• 遞迴地（recursive）把小於基準值元素的子數列和大於基準值元素的子數列排序。

對元素5兩邊的元素也重複以上操作，直到元素達到有序狀態

6.2 動圖演示

6.3 程式碼實現

public static void quickSort(int[] a,int low,int high){
        int start = low;
        int end = high;
        int key = a[low];
        while(end>start){
            //從後往前比較
            while(end>start&&a[end]>=key)  //如果沒有比關鍵值小的，比較下一個，直到有比關鍵值小的交換位置，然後又從前往後比較
                end--;
            if(a[end]<=key){
                int temp = a[end];
                a[end] = a[start];
                a[start] = temp;
            }
            //從前往後比較
            while(end>start&&a[start]<=key)//如果沒有比關鍵值大的，比較下一個，直到有比關鍵值大的交換位置
                start++;
            if(a[start]>=key){
                int temp = a[start];
                a[start] = a[end];
                a[end] = temp;
            }
            //此時第一次迴圈比較結束，關鍵值的位置已經確定了。左邊的值都比關鍵值小，右邊的值都比關鍵值大，但是兩邊的順序還有可能是不一樣的，進行下面的遞迴呼叫
        }
        //遞迴
        if(start>low) sort(a,low,start-1);//左邊序列。第一個索引位置到關鍵值索引-1
        if(end<high) sort(a,end+1,high);//右邊序列。從關鍵值索引+1到最後一個
    }

7、堆排序（Heap Sort）

堆排序（Heapsort）是指利用堆這種資料結構所設計的一種排序演算法。堆積是一個近似完全二叉樹的結構，並同時滿足堆積的性質：即子結點的鍵值或索引總是小於（或者大於）它的父節點。（若想升序則建立大根堆，若想降序，則建立小根堆）

7.1 演算法描述

• 將初始待排序關鍵字序列(R1,R2….Rn)構建成大頂堆，此堆為初始的無序區；
• 交換堆頂的元素和最後一個元素，此時最後一個位置作為有序區（有序區顯示為黃色），然後進行其他無序區的堆調整，重新得到大頂堆後，交換堆頂和倒數第二個元素的位置……；
• 由於交換後新的堆頂R[1]可能違反堆的性質，因此需要對當前無序區(R1,R2,……Rn-1)調整為新堆，然後再次將R[1]與無序區最後一個元素交換，得到新的無序區(R1,R2….Rn-2)和新的有序區(Rn-1,Rn)。不斷重複此過程直到有序區的元素個數為n-1，則整個排序過程完成。

7.2 動圖演示

7.3 程式碼實現

    //建立堆，在陣列arr中，從0到lastIndex建立堆
    public static void buildHeap(int[] arr,int lastIndex){
        int len=arr.length;
        for(int j=(lastIndex-1)/2;j>=0;j--){
            //k儲存正在判斷的節點
            int k=j;
            while (2*k+1<=lastIndex){
                int biggerIndex=2*k+1;
                if(biggerIndex<lastIndex){
                    if(arr[biggerIndex]<arr[biggerIndex+1]){
                        biggerIndex++;
                    }
                }
                if(arr[k]<arr[biggerIndex]){
                    swap(arr, k,biggerIndex);
                    k=biggerIndex;
                }else {
                    break;
                }
            }
        }
    }

    //交換元素的函式
    public static void swap(int[] arr,int i,int j){
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }
     //堆排序
    public static void heapSort(int[] arr){
        int len=arr.length;
        for(int i=0;i<len-1;i++){
            buildHeap(arr, len-1-i);
            swap(arr,0,len-1-i);
            System.out.println(Arrays.toString(arr));
        }
    }

8，計數排序（Counting Sort）

計算排序不是基於比較的排序演算法，其核心在於將輸入的資料值轉化為鍵儲存在額外開闢的陣列空間中。作為一種線性時間複雜度的排序，計數排序要求輸入的資料必須是有確定範圍的整數。

8.1演算法描述

• 找出待排序的陣列中最大和最小的元素;
• 統計陣列中每個值為我的元素出現的次數，存入陣列Ç的第我項;
• 對所有的計數累加（從ç中的第一個元素開始，每一項和前一項相加）;
• 反向填充目標陣列：將每個元素我放在新陣列的第C（ⅰ）項，每放一個元素就將C（ⅰ）減去1。

8.2動圖演示

8.3程式碼實現

  public static int[] countingSort(int[] arr,int maxValue){
        int[] C=new int[maxValue+1];//構造C陣列
        int len=arr.length;
        int sum=0;
        int[] B=new int[len];
        for(int i=0;i<len;i++){
            C[arr[i]]+=1;//統計arr中各元素的個數，存入C陣列
        }
        for(int i=0;i<maxValue+1;i++){
            sum+=C[i];
            C[i]=sum;
        }
        for(int i=len-1;i>=0;i--){
            B[C[arr[i]]-1]=arr[i];//將arr該元素放到排序後陣列B中指定的位置
            C[arr[i]]--;//將C中該元素-1，方便存放下一個同樣大小的元素
        }
        return B;//將排序好的陣列返回
    }

8.4演算法分析

計數排序是一個穩定的排序演算法。當輸入的元素是n個0到k之間的整數時，時間複雜度是O（n + k），空間複雜度也是O（n + k），其排序速度快於任何比較排序演算法。當ķ不是很大並且序列比較集中時，計數排序是一個很有效的排序演算法。

9，桶排序（Bucket Sort）

桶排序是計數排序的升級版。它利用了函式的對映關係，高效與否的關鍵就在於這個對映函式的確定。桶排序（Bucket sort）的工作的原理：假設輸入資料服從均勻分佈，將資料分到有限數量的桶裡，每個桶再分別排序（有可能再使用別的排序演算法或是以遞迴方式繼續使用桶排序進行排）。

9.1演算法描述

• 設定一個定量的陣列當作空桶;
• 遍歷輸入資料，並且把資料一個一個放到對應的桶裡去;
• 對每個不是空的桶進行排序;
• 從不是空的桶裡把排好序的資料拼接起來。

9.2圖片演示

9.3程式碼實現

   public static void bucketSort(int[] arr){
        int max = Integer.MIN_VALUE;
        int min = Integer.MAX_VALUE;
        for(int i = 0; i < arr.length; i++){
            max = Math.max(max, arr[i]);
            min = Math.min(min, arr[i]);
        }
        //桶數
        int bucketNum = (max - min) / arr.length + 1;
        ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketNum);
        for(int i = 0; i < bucketNum; i++){
            bucketArr.add(new ArrayList<Integer>());
        }
        //將每個元素放入桶
        for(int i = 0; i < arr.length; i++){
            int num = (arr[i] - min) / (arr.length);
            bucketArr.get(num).add(arr[i]);
        }
        int k=0;
        //對每個桶進行排序
        for(int i = 0; i < bucketArr.size(); i++){
            Collections.sort(bucketArr.get(i));
            for(int j=0;j<bucketArr.get(i).size();j++){
                arr[k]=bucketArr.get(i).get(j);
                k++;
            }
        }
        for (int i=0;i<bucketArr.size();i++){
            
        }
        System.out.println(bucketArr.toString());
    }

9.4演算法分析

桶排序最好情況下使用線性時間為O（n），桶排序的時間複雜度，取決與對各個桶之間資料進行排序的時間複雜度，因為其它部分的時間複雜度都為O（n）中。很顯然，桶劃分的越小，各個桶之間的資料越少，排序所用的時間也會越少。但相應的空間消耗就會增大。

10，基數排序（Radix Sort）

基數排序是按照低位先排序，然後收集;再按照高位排序，然後再收集。依次類推，直到最高位有時候有些屬性是有優先順序順序的，先按低優先順序排序，再按高優先順序排序。最後的次序就是高優先順序高的在前，高優先順序相同的低優先順序高的在前。

10.1演算法描述

• 取得陣列中的最大數，並取得位數;
• ARR為原始陣列，從最低位開始取每個位組成基數陣列;
• 對基數進行計數排序（利用計數排序適用於小範圍數的特點）;

10.2動圖演示

10.3程式碼實現

  public static void radixSort (int[]arr,int radix,int digits){ //radix表示基數（進位制），digits表示最大數值位數
        LinkedList<LinkedList> queue= new LinkedList<LinkedList>();
        for(int r =0;r <radix ;r ++){
            LinkedList<Integer> queue1= new LinkedList<Integer> ();
            queue.offer( queue1);   //offer用於queue中（Linkedlist同時實現了List和queue介面），add用於List中
        }
        //最大元素的位數,進行digits次分配和收集
        for(int i =0;i <digits ;i ++){
            //分配陣列元素
            for(int j =0;j <arr .length;j ++){
                //得到digits的第i+1位
                int r =(int)(arr[j]%Math. pow(radix , i+1)/Math.pow( radix, i));
                LinkedList<Integer> queue2=queue .get(r );
                queue2.offer( arr[ j]);
                queue.set( r, queue2);
            }
            //將收集佇列元素
            int count =0;
            for(int k =0;k <radix ;k ++){
                while(queue .get(k ).size()>0){
                    arr[ count++]=(Integer) queue.get( k).poll();
                }
            }
        }
    }

10.4演算法分析

基數排序基於分別排序，分別收集，所以是穩定的。但基數排序的效能比桶排序要略差，每一次關鍵字的桶分配都需要O（N）的時間複雜度，而且分配之後得到新的關鍵字序列又需要O（n）的時間複雜度。假如待排資料可以分為d個關鍵字，則基數排序的時間複雜度將是O（d * 2n），當然d要遠遠小於n，因此基本上還是線性級別的。

基數排序的空間複雜度為O（N + K），其中ķ為桶的數量一般來說。N >> K，因此額外空間需要大概Ñ個左右。