分類算法

時間 2020-02-27

標籤分類算法简体版

原文原文鏈接

目錄html

排序

排序

寫在前面

在網上有好多大神的，那我還要不要寫一遍。哎，大神的是大神的，和你飛某人有神魔關係，本身寫一遍是爲了本身理解，就當作是學習筆記吧。java

參考連接：ios

https://www.runoob.com/w3cnote/ten-sorting-algorithm.html算法

https://zhuanlan.zhihu.com/p/42586566shell

https://www.cnblogs.com/guoyaohua/p/8600214.htmlapi

知識框架

穩定性和時間複雜度比較

時間複雜度數組

平方階 ($O(n^2)$) 各種簡單排序：直接插入、直接選擇和冒泡排序。數據結構

線性對數階 ($O(nlog_2n)$) 快速排序、堆排序和歸併排序；框架

$O(n+§)$，§ 是介於 0 和 1 之間的常數。希爾排序dom

線性階 ($O(n)$) 基數排序，此外還有桶、箱排序。

穩定性

穩定的排序算法：冒泡排序、插入排序、歸併排序和基數排序。

不是穩定的排序算法：選擇排序、快速排序、希爾排序、堆排序。

名詞解釋

穩定：若是a本來在b前面,而且a=b,排序以後a仍然在b前面；

不穩定：若是a本來在b前面,而且a=b,排序以後a可在b後面；

內排序：全部排序操做都在內存中完成；

外排序：因爲數據太大，把數據放在磁盤中，而排序經過磁盤和內存的數據傳輸才能進行；

時間複雜度：一個算法執行所耗費的時間；

空間複雜度：運行完一個程序所消耗的內存大小

比較和非比較的區別

常見的快速排序、歸併排序、堆排序、冒泡排序等屬於比較排序。在排序的最終結果裏，元素之間的次序依賴於它們之間的比較。每一個數都必須和其餘數進行比較，才能肯定本身的位置。
在冒泡排序之類的排序中，問題規模爲n，又由於須要比較n次，因此平均時間複雜度爲O(n²)。在歸併排序、快速排序之類的排序中，問題規模經過分治法消減爲logN次，因此時間複雜度平均O(nlogn)。
比較排序的優點是，適用於各類規模的數據，也不在意數據的分佈，都能進行排序。能夠說，比較排序適用於一切須要排序的狀況。

計數排序、基數排序、桶排序則屬於非比較排序。非比較排序是經過肯定每一個元素以前，應該有多少個元素來排序。針對數組arr，計算arr[i]以前有多少個元素，則惟一肯定了arr[i]在排序後數組中的位置。
非比較排序只要肯定每一個元素以前的已有的元素個數便可，全部一次遍歷便可解決。算法時間複雜度O(n)。
非比較排序時間複雜度底，但因爲非比較排序須要佔用空間來肯定惟一位置。因此對數據規模和數據分佈有必定的要求。

1.直接插入排序（Insertion Sort）

直接插入排序（Insertion Sort）簡單直觀，基本思想是將待排記錄按關鍵字插入到前面已經排好的序列中，對於未排數據，從已經排列的數據從後往前掃描，找到相應的位置插入。因此在從後往前掃描時，須要反覆將已經排序的元素逐步後挪。

1.1算法描述

通常來講，插入排序都採用in-place在數組上實現。具體算法描述以下：

步驟1: 從第一個元素開始，該元素能夠認爲已經被排序；
步驟2: 取出下一個元素，在已經排序的元素序列中從後向前掃描。若是該元素（已排序）大於新元素，將該元素移到下一位置，直到找到已排序的元素小於或者等於新元素的位置，將新元素插入到該位置後；
步驟3: 重複步驟2。

1.2算法演示

1.3代碼實現

void insertion_sort(int arr[],int len){
        for(int i=1;i<len;i++){
                int key=arr[i];
                int j=i-1;
                while((j>=0) && (key<arr[j])){
                        arr[j+1]=arr[j];
                        j--;
                }
                arr[j+1]=key;
        }
}

1.4算法分析

複雜度

**空間上**：只需一個記錄的輔助空間

時間上：排序的基本操做爲比較和移動

最佳狀況 當待排列的記錄按關鍵字非遞減有序排列（正序）時，所需進行關鍵字之間的比較次數最小爲n-1 ($\sum_{i=2}^n1$), 記錄不須要移動, $O(n)$

最差狀況 噹噹待排列的記錄按關鍵字非遞增有序排列（逆序）時，所需進行關鍵字之間的比較次數最大(n+2)(n-1)/2($\sum_{i=2}^ni$ ), 記錄移動次數也變爲最大(n+4)(n-1)/2($\sum_{i=2}^n{i+1}$)

平均狀況 可取上述最大值和最小值的平均值，$O(n^2)$

穩定性

因爲只須要找到不大於當前數的位置而並不須要交換，所以，直接插入排序是穩定的排序方法

使用場景

插入排序因爲 $O(n^2)$的複雜度，在數組較大的時候不適用。可是，在數據比較少的時候，是一個不錯的選擇，通常作爲快速排序的擴充。例如，在STL的sort算法和stdlib的qsort算法中，都將插入排序做爲快速排序的補充，用於少許元素的排序。又如，在JDK 7 java.util.Arrays所用的sort方法的實現中，當待排數組長度小於47時，會使用插入排序。

1.5優化—— 折半插入排序(Binary Insertion Sort)

因爲直接插入排序的基本操做是查找和插入。能夠用」折半查找「來實現，所以折半插入排序僅減小了關鍵字之間的比較次數，而記錄的移動次數不變，時間複雜度仍爲$O(n)$

void BInsertSort(int L[],int length){
    //對順序表L進行折半插入排序
    int low,high,temp,mid;
    for( int i=1;i<=length;++i){
        temp=L[i];      //將L.r[i ]暫存到temp
        low=0;  high=i-1;
        while(low<=high){   //在r[low...high]中折半查找有序插入的位置 
             mid=(low+high)/2; //折半 
            if(temp<L[mid])
               high=mid-1;    //插入點在低半段
            else
               low=mid+1;    //插入點在高半區 
        }
        for( int j=i-1;j>=high+1;--j)
           L[j+1]=L[j];//記錄後移 
       L[high+1]=temp;//插入 
    } 
}

2. 希爾排序(Diminishing Increment Sort)

在希爾排序出現以前，計算機界廣泛存在「排序算法不可能突破$O(n^2)$」的觀點。希爾排序是第一個突破$O(n^2)$的排序算法，它是簡單插入排序的改進版。希爾排序的提出，主要基於如下兩點：

插入排序算法在數組基本有序的狀況下，能夠近似達到O(n)複雜度，效率極高。
但插入排序每次只能將數據移動一位，在數組較大且基本無序的狀況下性能會迅速惡化。

2.1 算法描述

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

選擇一個增量序列 $t_1，t_2，…，t_k，其中t_i>t_j，t_k=1$；
按增量序列個數$k$，對序列進行$ k $趟排序；
每趟排序，根據對應的增量$t_i$，將待排序列分割成若干長度爲$m$ 的子序列，分別對各子表進行直接插入排序。僅增量因子爲$1$ 時，整個序列做爲一個表來處理，表長度即爲整個序列的長度。

2.2算法演示

2.3代碼實現

希爾增量 n/2 (n/2)/2 ... 1

希爾增量 n/2 (n/2)/2 ... 1
void shell_sort(int arr[], int len) {
    int gap, i, j;
    int temp;
    for (gap = len >> 1; gap > 0; gap >>= 1)
          for (i = gap; i < len; i++) {
               temp = arr[i];
               for (j = i - gap; j >= 0 && arr[j] > temp; j -= gap)
                      arr[j + gap] = arr[j];
               arr[j + gap] = temp;
         }
}

$O(n^{3/2})$ by Knuth 1, 4, 13, 40, 121...

template<typename T>
void shell_sort(T array[], int length) {
    int h = 1;
    while (h < length / 3) {
        h = 3 * h + 1;
    }
    while (h >= 1) {
        for (int i = h; i < length; i++) {
            for (int j = i; j >= h && array[j] < array[j - h]; j -= h) {
                std::swap(array[j], array[j - h]);
            }
        }
        h = h / 3;
    }
}

2.4增量序列

希爾排序的增量數列能夠任取，須要的惟一條件是最後一個必定爲1（由於要保證按1有序）。可是，不一樣的數列選取會對算法的性能形成極大的影響。上面的代碼演示了兩種增量。
切記：增量序列中每兩個元素最好不要出現1之外的公因子！（很顯然，按4有序的數列再去按2排序意義並不大）。

下面是一些常見的增量序列。

Donald Shell增量。折半下降直到1。據研究，使用希爾增量，其時間複雜度仍是$O(n^2)$。
Hibbard 增量。

遞推公式：
$h_1=1,h_i=2∗h_{i−1}+1$

1,3,7,15,31,63,127,255,511,1023......

最壞時間複雜度爲$ Θ(N^{3/2})$；平均時間複雜度約爲 $O(N^{5/4})$。
Knuth增量。

遞推公式：

$h_1=1,h_i=3∗h_{i−1}+1$

1,4,13,40,121,364,1093,3280......

最壞時間複雜度爲 $O(N^{4/3})O(N^{4/3})$；平均時間複雜度約爲 $O(N^{7/6})$
Sedgewick增量。

通項公式：

$h_i=max(9∗4^j−9∗2^j+1,4^k−3∗2^k+1)$

1,5,19,41,109.209,505,929,2161,3905......

2.5算法分析

空間複雜度：只需一個記錄的輔助空間

穩定性

咱們都知道插入排序是穩定算法。可是，Shell排序是一個屢次插入的過程。在一次插入中咱們能確保不移動相同元素的順序，但在屢次的插入中，相同元素徹底有可能在不一樣的插入輪次被移動，最後穩定性被破壞，所以，Shell排序不是一個穩定的算法

適用場景

Shell排序雖然快，可是畢竟是插入排序，其數量級並無後起之秀--快速排序$O(n log n)$ 。在大量數據面前，Shell排序不是一個好的算法。可是，中小型規模的數據徹底可使用它。

3. 冒泡排序(Bubble Sort)

冒泡排序是一種簡單的排序算法。它重複地走訪過要排序的數列，一次比較兩個元素，若是它們的順序錯誤就把它們交換過來。每趟排序使得關鍵字大的記錄安置到最後。在冒泡過程當中，關鍵字較小的記錄比如水中的氣泡逐趟上升，而關鍵字較大的記錄數則比如石塊逐趟下沉，每一趟有一塊「最大」的石塊下沉到底部。

3.1算法描述

首先將第一個記錄的關鍵字和第二個記錄的關鍵字進行比較，若是未逆序則進行交換，以此類推，一直到第n-1和n個記錄的關鍵字進行比較爲止。上述過程稱爲一次冒泡排序，其結果使得關鍵字最大的記錄被安排在最後一個記錄的位置上。

而後進行第二趟排序，對前n-1個記錄進行一樣操做，其結果是關鍵字次大的記錄數被安排在第n-1個位置。

通常的，第i趟排序是從$L.r[1]$到$L.r[n-i+1]$依次比較相鄰兩個記錄的關鍵字，並在逆序時交換位置，其結果是這$n-i+1$個記錄中關鍵字最大的記錄被交換到第$n-i+1$的位置。

整個排序過程須要進行$k(1\leq k<n)$趟排序。顯然，判斷排序結束的條件是「在一條趟排序過程當中沒有進行交換記錄的操做」。

3.2算法演示

3.4代碼實現

#include <iostream>
using namespace std;
template<typename T> 
//整數或浮點數皆可以使用,若要使用類(class)或結構體(struct)時必須重載大於(>)運算符
void bubble_sort(T arr[], int len) {
        int i, j;
        for (i = 0; i < len - 1; i++)
                for (j = 0; j < len - 1 - i; j++)
                        if (arr[j] > arr[j + 1])
                                swap(arr[j], arr[j + 1]);
}
int main() {
        int arr[] = { 61, 17, 29, 22, 34, 60, 72, 21, 50, 1, 62 };
        int len = (int) sizeof(arr) / sizeof(*arr);
        bubble_sort(arr, len);
        for (int i = 0; i < len; i++)
                cout << arr[i] << ' ';
        cout << endl;
        float arrf[] = { 17.5, 19.1, 0.6, 1.9, 10.5, 12.4, 3.8, 19.7, 1.5, 25.4, 28.6, 4.4, 23.8, 5.4 };
        len = (float) sizeof(arrf) / sizeof(*arrf);
        bubble_sort(arrf, len);
        for (int i = 0; i < len; i++)
                cout << arrf[i] << ' '<<endl;
        return 0;
}

3.5算法分析

複雜度

在數據徹底有序的時候展示出最優時間複雜度，爲$O(n)$。其餘狀況下，幾乎老是$O( n^2 )$。所以，算法在數據基本有序的狀況下，性能最好

穩定性

在相鄰元素相等時，它們並不會交換位置，因此，冒泡排序是穩定排序。

3.6算法改進

要使算法在最佳狀況下有$O(n)$複雜度，須要作一些改進，增長一個swap的標誌，當前一輪沒有進行交換時，說明數組已經有序，沒有必要再進行下一輪的循環了，直接退出。

public static void bubbleSort(int[] arr) {
    int temp = 0;
    boolean swap;
    for (int i = arr.length - 1; i > 0; i--) { // 每次須要排序的長度
        swap=false;
        for (int j = 0; j < i; j++) { // 從第一個元素到第i個元素
            if (arr[j] > arr[j + 1]) {
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
                swap=true;
            }
        }//loop j
        if (swap==false){
            break;
        }
    }//loop i
}// method bubbleSort

4. 快速排序(Quick Sort)

快速排序對於大數據的優秀排序性能和相同複雜度算法中相對簡單的實現使它註定獲得比其餘算法更多的寵愛。

快速排序的最壞運行狀況是 O(n²)，好比說順序數列的快排。但它的平攤指望時間是 O(nlogn)，且 O(nlogn) 記號中隱含的常數因子很小，比複雜度穩定等於 O(nlogn) 的歸併排序要小不少。因此，對絕大多數順序性較弱的隨機數列而言，快速排序老是優於歸併排序

基本思想是，經過一趟排序將待排記錄分割爲獨立的兩部分，其中一部分的記錄的關鍵字均小於另外一部分記錄的關鍵字，則可分別對這兩部分記錄繼續排序，以達到整個記錄均有序。

4.1算法描述

從數列中挑出一個元素，稱爲"基準"（pivot），
從新排序數列，全部比基準值小的元素擺放在基準前面，全部比基準值大的元素擺在基準後面（相同的數能夠到任何一邊）。在這個分區結束以後，該基準就處於數列的中間位置。這個稱爲分區（partition）操做。
遞歸地（recursively）把小於基準值元素的子數列和大於基準值元素的子數列排序。

4.2算法演示

4.3代碼實現

//嚴蔚敏《數據結構》標準分割函數
 Paritition1(int A[], int low, int high) {
   int pivot = A[low];          //樞紐記錄關鍵字
   while (low < high) {         //從表的兩端交替向中間掃描
     while (low < high && A[high] >= pivot) {
       --high;
     }
     A[low] = A[high];          //將樞紐記錄小的記錄移到低端
     while (low < high && A[low] <= pivot) {
       ++low;
     }
     A[high] = A[low];          //將樞紐記錄大的記錄移到高端
   }
   A[low] = pivot;              //樞紐記錄到位
   return low;                  //返回樞紐位置
 }

 void QuickSort(int A[], int low, int high) //快排母函數
 {
   if (low < high) {                        //長度大於1
     int pivot = Paritition1(A, low, high); //將A一分爲二
     QuickSort(A, low, pivot - 1);          //對低子表遞歸排序
     QuickSort(A, pivot + 1, high);
   }
 }

4.4算法分析

複雜度

空間上

快速排序須要一個棧空間來實現遞歸。若每趟排序都將記錄均勻分割爲長度近似的兩個子序列，則棧的最大深度爲$\lfloor log_2 n\rfloor +1$ (包括最外層參量進棧)，可是，若每趟排序以後，樞紐位置均偏向子序列的一端，則爲最壞狀況，棧的最大深度爲$n$。

時間上 $O(nlogn)$

一般，快速排序被認爲是，在全部同數量級（$O(nlogn)$）的排序方法中，其平均性能最好。可是若是初始記錄按關鍵字有序或者基本有序時，快速排序將蛻化爲冒泡排序，其時間複雜度爲$O(n^2)$。爲改進之，一般依「三者取中」的法則來選取樞紐記錄.經驗證實，採用三者取中的規則可大大改善快速排序在最壞狀況下的性能。然而，即便如此，也不能使快速排序在待排記錄序列按關鍵字有序時達到$O(n)$的時間複雜度。

穩定性

快速排序並非穩定的。這是由於咱們沒法保證相等的數據按順序被掃描到和按順序存放。

4.5 算法改進

STL庫將快速排序作了改進。沒有使用兩邊遞歸，而是一邊遞歸，另外一邊循環。而且使用了「三者取中」的規則。

template<typename _RandomAccessIterator, typename _Size, typename _Compare>
    void  __introsort_loop(_RandomAccessIterator __first,
                            _RandomAccessIterator __last,
                             _Size __depth_limit, _Compare __comp)
{
      while (__last - __first > int(_S_threshold))
      {
      /*堆排序部分,當快速排序層數過大時，改用堆排序
      if (__depth_limit == 0)
        {
          std::__partial_sort(__first, __last, __last, __comp);
          return;
        }
      --__depth_limit;
      */
      //將集合分爲兩部分
      _RandomAccessIterator __cut =
        std::__unguarded_partition_pivot(__first, __last, __comp);
      //後一半遞歸
      std::__introsort_loop(__cut, __last, __depth_limit, __comp);
      //前一半繼續排序
      __last = __cut;
    }
}
    //
    template<typename _RandomAccessIterator, typename _Compare>
    inline _RandomAccessIterator
    __unguarded_partition_pivot(_RandomAccessIterator __first,
                _RandomAccessIterator __last, _Compare __comp)
{ //取三點中值
      _RandomAccessIterator __mid = __first + (__last - __first) / 2;
      std::__move_median_to_first(__first, __first + 1, __mid, __last - 1,
                  __comp);
      return std::__unguarded_partition(__first + 1, __last, __first, __comp);
}
    //快速排序的主體部分
    template<typename _RandomAccessIterator, typename _Compare>
    _RandomAccessIterator
    __unguarded_partition(_RandomAccessIterator __first,
              _RandomAccessIterator __last,
              _RandomAccessIterator __pivot, _Compare __comp)
{
      while (true)
    {
      while (__comp(__first, __pivot))
        ++__first;
      --__last;
      while (__comp(__pivot, __last))
        --__last;
      if (!(__first < __last))
        return __first;
      std::iter_swap(__first, __last);
      ++__first;
    }
}

5. 簡單選擇排序(Simple Selection Sort)

冒泡算法，每次比較若是發現較小的元素在後面，就交換兩個相鄰的元素。而選擇排序算法的改進在於：先並不急於調換位置，先從A[1]開始逐個檢查，看哪一個數最小就記下該數所在的位置P，等一躺掃描完畢，再把A[P]和A[1]對調，這時A[1]到A[10]中最小的數據就換到了最前面的位置。因此，選擇排序每掃描一遍數組，只須要一次真正的交換，而冒泡可能須要屢次。比較的次數是同樣的。

5.1算法描述

在未排序序列中找到最小（大）元素，存放到排序序列的起始位置
從剩餘未排序元素中繼續尋找最小（大）元素，而後放到已排序序列的末尾。
重複第二步，直到全部元素均排序完畢。

5.2算法演示

5.3代碼實現

template<typename T> 
//整數或浮點數皆可以使用，若要使用物件（class）時必須設定大於（>）的運算子功能
void selection_sort(std::vector<T>& arr) {
        for (int i = 0; i < arr.size() - 1; i++) {
                int min = i;
                for (int j = i + 1; j < arr.size(); j++)
                        if (arr[j] < arr[min])
                                min = j;
                std::swap(arr[i], arr[min]);
        }
}

5.4算法分析

穩定性

用數組實現的選擇排序是不穩定的，用鏈表實現的選擇排序是穩定的。
不過，通常提到排序算法時，你們每每會默認是數組實現，因此選擇排序是不穩定的

複雜度

所須要的進行記錄移動的操做次數最少爲「0」，最大爲$3(n-1)$，然而，不論記錄的初始排列如何，所須要的進行關鍵字間的比較次數相同均爲$n(n-1)/2$。所以總的時間複雜度爲$O(n^2)$

使用場景

選擇排序實現也比較簡單，而且因爲在各類狀況下複雜度波動小，所以通常是優於冒泡排序的。在全部的徹底交換排序中，選擇排序也是比較不錯的一種算法。可是，因爲固有的$O(n^2)$複雜度，選擇排序在海量數據面前顯得力不從心。所以，它適用於簡單數據排序。

6. 堆排序(Heap Sort)

堆排序(Heap Sort)是指利用堆積樹（堆）這種數據結構所設計的一種排序算法，它是選擇排序的一種。能夠利用數組的特色快速定位指定索引的元素。堆排序就是把最大堆堆頂的最大數取出，將剩餘的堆繼續調整爲最大堆，再次將堆頂的最大數取出，這個過程持續到剩餘數只有一個時結束。

6.1堆的概念

堆是一種特殊的徹底二叉樹（complete binary tree）。徹底二叉樹的一個「優秀」的性質是，除了最底層以外，每一層都是滿的，這使得堆能夠利用數組來表示（普通的通常的二叉樹一般用鏈表做爲基本容器表示），每個結點對應數組中的一個元素。

以下圖，是一個堆和數組的相互關係：

對於給定的某個結點的下標 i，能夠很容易的計算出這個結點的父結點、孩子結點的下標：

Parent(i) = floor(i/2)，i 的父節點下標
Left(i) = 2i，i 的左子節點下標
Right(i) = 2i + 1，i 的右子節點下標

二叉堆通常分爲兩種：最大堆和最小堆。
最大堆：
最大堆中的最大元素值出如今根結點（堆頂）
堆中每一個父節點的元素值都大於等於其孩子結點（若是存在）

最小堆：
最小堆中的最小元素值出如今根結點（堆頂）
堆中每一個父節點的元素值都小於等於其孩子結點（若是存在）

堆排序原理

堆排序就是把最大堆堆頂的最大數取出，將剩餘的堆繼續調整爲最大堆，再次將堆頂的最大數取出，這個過程持續到剩餘數只有一個時結束。在堆中定義如下幾種操做：

最大堆調整（Max-Heapify）：將堆的末端子節點做調整，使得子節點永遠小於父節點
建立最大堆（Build-Max-Heap）：將堆全部數據從新排序，使其成爲最大堆
堆排序（Heap-Sort）：移除位在第一個數據的根節點，並作最大堆調整的遞歸運算繼續進行下面的討論前，須要注意的一個問題是：數組都是 Zero-Based，這就意味着咱們的堆數據結構模型要發生改變

相應的，幾個計算公式也要做出相應調整：

Parent(i) = floor((i-1)/2)，i 的父節點下標
Left(i) = 2i + 1，i 的左子節點下標
Right(i) = 2(i + 1)，i 的右子節點下標

堆的創建和維護

堆能夠支持多種操做，但如今咱們關心的只有兩個問題：

給定一個無序數組，如何創建爲堆？
刪除堆頂元素後，如何調整數組成爲新堆？

先看第二個問題。假定咱們已經有一個現成的大根堆。如今咱們刪除了根元素，但並無移動別的元素。想一想發生了什麼：根元素空了，但其它元素還保持着堆的性質。咱們能夠把最後一個元素（代號A）移動到根元素的位置。若是不是特殊狀況，則堆的性質被破壞。但這僅僅是因爲A小於其某個子元素。因而，咱們能夠把A和這個子元素調換位置。若是A大於其全部子元素，則堆調整好了；不然，重複上述過程，A元素在樹形結構中不斷「下沉」，直到合適的位置，數組從新恢復堆的性質。上述過程通常稱爲「篩選」，方向顯然是自上而下。

刪除後的調整，是把最後一個元素放到堆頂，自上而下比較

刪除一個元素是如此，插入一個新元素也是如此。不一樣的是，咱們把新元素放在末尾，而後和其父節點作比較，即自下而上篩選。

插入是把新元素放在末尾，自下而上比較

那麼，第一個問題怎麼解決呢？

常規方法是從第一個非葉子結點向下篩選，直到根元素篩選完畢。這個方法叫「篩選法」，須要循環篩選n/2個元素。

但咱們還能夠借鑑「插入排序」的思路。咱們能夠視第一個元素爲一個堆，而後不斷向其中添加新元素。這個方法叫作「插入法」，須要循環插入(n-1)個元素。

因爲篩選法和插入法的方式不一樣，因此，相同的數據，它們創建的堆通常不一樣。大體瞭解堆以後，堆排序就是水到渠成的事情了。

6.2 算法演示

6.3算法描述

創建最大堆，倒着輸出，在最後一個位置輸出最大值，次末位置輸出次大值……因爲每次輸出的最大元素會騰出第一個空間，所以，咱們剛好能夠放置這樣的元素而不須要額外空間。

將初始待排序關鍵字序列(R1,R2….Rn)構建成大頂堆，此堆爲初始的無序區；
將堆頂元素R[1]與最後一個元素R[n]交換，此時獲得新的無序區(R1,R2,……Rn-1)和新的有序區(Rn),且知足R[1,2…n-1]<=R[n]；
因爲交換後新的堆頂R[1]可能違反堆的性質，所以須要對當前無序區(R1,R2,……Rn-1)調整爲新堆，而後再次將R[1]與無序區最後一個元素交換，獲得新的無序區(R1,R2….Rn-2)和新的有序區(Rn-1,Rn)。不斷重複此過程直到有序區的元素個數爲n-1，則整個排序過程完成。

6.3算法實現

#include <iostream>
#include <algorithm>
using namespace std;

void max_heapify(int arr[], int start, int end) {
    // 創建父節點指標和子節點指標
    int dad = start;
    int son = dad * 2 + 1;
    while (son <= end) { // 若子節點指標在範圍內才作比較
        if (son + 1 <= end && arr[son] < arr[son + 1]) // 先比較兩個子節點大小，選擇最大的
            son++;
        if (arr[dad] > arr[son]) // 若是父節點大於子節點表明調整完畢，直接跳出函數
            return;
        else { // 否則交換父子內容再繼續子節點和孫節點比較
            swap(arr[dad], arr[son]);
            dad = son;
            son = dad * 2 + 1;
        }
    }
}

void heap_sort(int arr[], int len) {
    // 初始化，i從最後一個父節點開始調整
    for (int i = len / 2 - 1; i >= 0; i--)
        max_heapify(arr, i, len - 1);
    // 先將第一個元素和已經排好的元素前一位作交換，再從新調整(剛調整的元素以前的元素)，直到排序完畢
    for (int i = len - 1; i > 0; i--) {
        swap(arr[0], arr[i]);
        max_heapify(arr, 0, i - 1);
    }
}

int main() {
    int arr[] = {60,91,13,19,30,10,35,81,77,20,22,96,31,46,65};
    int len = (int) sizeof(arr) / sizeof(*arr);
    heap_sort(arr, len);
    for (int i = 0; i < len; i++)
        cout << arr[i] << ' ';
    cout << endl;
    return 0;
}

6.4算法分析

穩定性

堆排序存在大量的篩選和移動過程，屬於不穩定的排序算法。

複雜度

空間上

僅需一個記錄大小供交換用的輔助空間

時間上 $O(nlogn)$

堆排序在最壞狀況下，其時間複雜度也爲$O(nlogn)$。

其運行時間主要耗費在建最初堆和調整新堆時進行的反覆「篩選」上。對深度爲$k$的堆，篩選算法中進行關鍵字的比較次數至多爲$2(k-1)$次，則在建含$n$個元素、深度爲$h$的堆時，總共進行的關鍵字比較次數不會超過$4n$。又，$n$個結點的徹底二叉樹的深度爲$\lfloor log_2 n \rfloor +1$，則進行重建新堆時調用Heap Adjust 過程$n-1$次，總共進行的比較次數不超過$2n(\lfloor log_2 n \rfloor) $。

使用場景

堆排序在創建堆和調整堆的過程當中會產生比較大的開銷，在元素少的時候並不適用。可是，在元素比較多的狀況下，仍是不錯的一個選擇。尤爲是在解決諸如「前n大的數」一類問題時，幾乎是首選算法。

7. 歸併排序(Merging Sort)

歸併排序是創建在歸併操做上的一種有效的排序算法。該算法是採用分治法的一個很是典型的應用。將已有序的子序列合併，獲得徹底有序的序列；即先使每一個子序列有序，再使子序列段間有序。若將兩個有序表合併成一個有序表，稱爲2-路歸併。

7.1算法描述

兩種方法

遞歸法（Top-down）

申請空間，使其大小爲兩個已經排序序列之和，該空間用來存放合併後的序列
設定兩個指針，最初位置分別爲兩個已經排序序列的起始位置
比較兩個指針所指向的元素，選擇相對小的元素放入到合併空間，並移動指針到下一位置
重複步驟3直到某一指針到達序列尾
將另外一序列剩下的全部元素直接複製到合併序列尾

迭代法（Bottom-up）

原理以下（假設序列共有n個元素）：

將序列每相鄰兩個數字進行歸併操做，造成ceil(n/2)個序列，排序後每一個序列包含兩/一個元素
若此時序列數不是1個則將上述序列再次歸併，造成ceil(n/4)個序列，每一個序列包含四/三個元素
重複步驟2，直到全部元素排序完畢，即序列數爲1

7.2算法演示

7.3算法實現

C++

遞歸版：

void MergeSort(vector<int> &Array, int front, int end) {
    if (front >= end)
        return;
    int mid = (front + end) / 2; //將Array平分
    MergeSort(Array, front, mid);//遞歸地將Array[front,mid]歸併爲有序
    MergeSort(Array, mid + 1, end);//遞歸地將Array[mid+1,end]歸併爲有序
    Merge(Array, front, mid, end);//將Array[front,mid]，Array[mid+1,end]合併
}
void Merge(vector<int> &Array, int front, int mid, int end) {
    // preconditions:
    // Array[front...mid] is sorted
    // Array[mid+1 ... end] is sorted
    // Copy Array[front ... mid] to LeftSubArray
    // Copy Array[mid+1 ... end] to RightSubArray
    vector<int> LeftSubArray(Array.begin() + front, Array.begin() + mid + 1);
    vector<int> RightSubArray(Array.begin() + mid + 1, Array.begin() + end + 1);
    int idxLeft = 0, idxRight = 0;
    LeftSubArray.insert(LeftSubArray.end(), numeric_limits<int>::max());
    RightSubArray.insert(RightSubArray.end(), numeric_limits<int>::max());
    // Pick min of LeftSubArray[idxLeft] and RightSubArray[idxRight], and put into Array[i]
    for (int i = front; i <= end; i++) {
        if (LeftSubArray[idxLeft] < RightSubArray[idxRight]) {
            Array[i] = LeftSubArray[idxLeft];
            idxLeft++;
        } else {
            Array[i] = RightSubArray[idxRight];
            idxRight++;
        }
    }
}

迭代版：

template<typename T> 
// 整數或浮點數皆可以使用,若要使用物件(class)時必須設定"小於"(<)的運算子功能
void merge_sort(T arr[], int len) {
  T *a = arr;
  T *b = new T[len];
  for (int seg = 1; seg < len; seg += seg) {//控制seg迭代來實現
      for (int start = 0; start < len; start += seg + seg) {
           int low = start, mid = min(start + seg, len), high = min(start + seg + seg, len);
           int k = low;
           int start1 = low, end1 = mid;
           int start2 = mid, end2 = high;
           while (start1 < end1 && start2 < end2)
               b[k++] = a[start1] < a[start2] ? a[start1++] : a[start2++];
           while (start1 < end1)
               b[k++] = a[start1++];
           while (start2 < end2)
               b[k++] = a[start2++];
      }
      T *temp = a;
      a = b;
      b = temp;
  }
  if (a != arr) {
      for (int i = 0; i < len; i++)
           b[i] = a[i];
      b = a;
   }
   delete[] b;
}

7.4算法分析

穩定性

由於咱們在遇到相等的數據的時候必然是按順序「抄寫」到輔助數組上的，因此，歸併排序一樣是穩定算法

複雜度

空間上

空間複雜度O(n)，實現歸併排序須要和記錄等數量的輔助空間。

時間上

時間複雜度$O(nlogn)$

8. 基數排序(Radix Sorting)

基數排序是一種非比較型整數排序算法，其原理是將整數按位數切割成不一樣的數字，而後按每一個位數分別比較。因爲整數也能夠表達字符串（好比名字或日期）和特定格式的浮點數，因此基數排序也不是隻能使用於整數。

8.1算法描述

取得數組中的最大數，並取得位數；
arr爲原始數組，從最低位開始取每一個位組成radix數組；
對radix進行計數排序（利用計數排序適用於小範圍數的特色）；

8.2算法演示

8.3代碼實現

int maxbit(int data[], int n) //輔助函數，求數據的最大位數
{
    int maxData = data[0];              ///< 最大數
    /// 先求出最大數，再求其位數，這樣有原先依次每一個數判斷其位數，稍微優化點。
    for (int i = 1; i < n; ++i)
    {
        if (maxData < data[i])
            maxData = data[i];
    }
    int d = 1;
    int p = 10;
    while (maxData >= p)
    {
        //p *= 10; // Maybe overflow
        maxData /= 10;
        ++d;
    }
    return d;
/*    int d = 1; //保存最大的位數
    int p = 10;
    for(int i = 0; i < n; ++i)
    {
        while(data[i] >= p)
        {
            p *= 10;
            ++d;
        }
    }
    return d;*/
}
void radixsort(int data[], int n) //基數排序
{
    int d = maxbit(data, n);
    int *tmp = new int[n];
    int *count = new int[10]; //計數器
    int i, j, k;
    int radix = 1;
    for(i = 1; i <= d; i++) //進行d次排序
    {
        for(j = 0; j < 10; j++)
            count[j] = 0; //每次分配前清空計數器
        for(j = 0; j < n; j++)
        {
            k = (data[j] / radix) % 10; //統計每一個桶中的記錄數
            count[k]++;
        }
        for(j = 1; j < 10; j++)
            count[j] = count[j - 1] + count[j]; //將tmp中的位置依次分配給每一個桶
        for(j = n - 1; j >= 0; j--) //將全部桶中記錄依次收集到tmp中
        {
            k = (data[j] / radix) % 10;
            tmp[count[k] - 1] = data[j];
            count[k]--;
        }
        for(j = 0; j < n; j++) //將臨時數組的內容複製到data中
            data[j] = tmp[j];
        radix = radix * 10;
    }
    delete []tmp;
    delete []count;
}

8.4算法分析

穩定性

基數排序是按照低位先排序，而後收集；再按照高位排序，而後再收集；依次類推，直到最高位。先按低優先級排序，再按高優先級排序。最後的次序就是高優先級高的在前，高優先級相同的低優先級高的在前。基數排序基於分別排序，分別收集，因此是穩定的。

複雜度

9計數排序(Counting Sort)

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

計數排序的算法的原理，它不須要去跟其餘元素比來比去，而是一開始就知道本身的位置，因此直接歸位。在計數的該元素出現的詞頻數組裏面，出現一次，就直接加一次便可，若是沒有出現改位置就是0。最後該位置的詞頻，就是表明其在原始數組裏面出現的次數。因爲詞頻數組的index是從0開始，因此最後直接遍歷輸出這個數組裏面的每個大於0的元素值便可。

9.1算法描述

找出待排序的數組中最大和最小的元素；
統計數組中每一個值爲i的元素出現的次數，存入數組C的第i項；
對全部的計數累加（從C中的第一個元素開始，每一項和前一項相加）；
反向填充目標數組：將每一個元素i放在新數組的第C(i)項，每放一個元素就將C(i)減去1

9.2算法演示

9.4代碼實現

public class CountingSort implements IArraySort {

    @Override
    public int[] sort(int[] sourceArray) throws Exception {
        // 對 arr 進行拷貝，不改變參數內容
        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);

        int maxValue = getMaxValue(arr);

        return countingSort(arr, maxValue);
    }

    private int[] countingSort(int[] arr, int maxValue) {
        int bucketLen = maxValue + 1;
        int[] bucket = new int[bucketLen];

        for (int value : arr) {
            bucket[value]++;
        }

        int sortedIndex = 0;
        for (int j = 0; j < bucketLen; j++) {
            while (bucket[j] > 0) {
                arr[sortedIndex++] = j;
                bucket[j]--;
            }
        }
        return arr;
    }

    private int getMaxValue(int[] arr) {
        int maxValue = arr[0];
        for (int value : arr) {
            if (maxValue < value) {
                maxValue = value;
            }
        }
        return maxValue;
    }

}

9.5算法分析

穩定性

複雜度

當輸入的元素是n 個0到k之間的整數時，它的運行時間是 O(n + k)。計數排序不是比較排序，排序的速度快於任何比較排序算法。因爲用來計數的數組C的長度取決於待排序數組中數據的範圍（等於待排序數組的最大值與最小值的差加上1），這使得計數排序對於數據範圍很大的數組，須要大量時間和內存。

空間上

$O(n)$

適用場景

排序目標要可以映射到整數域，其最大值最小值應當容易辨別。另外，計數排序須要佔用大量空間，它比較適用於數據比較集中的狀況。

計數排序在特定的狀況下，排序效率極高，可是若是排序的計數空間範圍過大，而實際元素個數很是小的狀況，效率就會很是差，好比，我只有3個元素，3，1，500000，這樣的狀況實際上是不適合用計數排序的

10桶排序(Bucket Sort)

桶排序是計數排序的升級版。它利用了函數的映射關係，高效與否的關鍵就在於這個映射函數的肯定。爲了使桶排序更加高效，咱們須要作到這兩點：

在額外空間充足的狀況下，儘可能增大桶的數量
使用的映射函數可以將輸入的 N 個數據均勻的分配到 K 個桶中

同時，對於桶中元素的排序，選擇何種比較排序算法對於性能的影響相當重要

10.1算法描述

找出待排序數組中的最大值max、最小值min。設置桶中放置的數值。
咱們使用動態數組ArrayList 做爲桶，桶裏放的元素也用 ArrayList 存儲。桶的數量爲(max-min)/arr.length+1
遍歷數組 arr，計算每一個元素 arr[i] 放的桶
每一個桶各自排序
遍歷桶數組，把排序好的元素放進輸出數組

10.2算法演示

10.3 代碼實現

public class BucketSort implements IArraySort {

    private static final InsertSort insertSort = new InsertSort();

    @Override
    public int[] sort(int[] sourceArray) throws Exception {
        // 對 arr 進行拷貝，不改變參數內容
        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);

        return bucketSort(arr, 5);
    }

    private int[] bucketSort(int[] arr, int bucketSize) throws Exception {
        if (arr.length == 0) {
            return arr;
        }

        int minValue = arr[0];
        int maxValue = arr[0];
        for (int value : arr) {
            if (value < minValue) {
                minValue = value;
            } else if (value > maxValue) {
                maxValue = value;
            }
        }

        int bucketCount = (int) Math.floor((maxValue - minValue) / bucketSize) + 1;
        int[][] buckets = new int[bucketCount][0];

        // 利用映射函數將數據分配到各個桶中
        for (int i = 0; i < arr.length; i++) {
            int index = (int) Math.floor((arr[i] - minValue) / bucketSize);
            buckets[index] = arrAppend(buckets[index], arr[i]);
        }

        int arrIndex = 0;
        for (int[] bucket : buckets) {
            if (bucket.length <= 0) {
                continue;
            }
            // 對每一個桶進行排序，這裏使用了插入排序
            bucket = insertSort.sort(bucket);
            for (int value : bucket) {
                arr[arrIndex++] = value;
            }
        }

        return arr;
    }

    /**
     * 自動擴容，並保存數據
     *
     * @param arr
     * @param value
     */
    private int[] arrAppend(int[] arr, int value) {
        arr = Arrays.copyOf(arr, arr.length + 1);
        arr[arr.length - 1] = value;
        return arr;
    }

}