????本文將通過動態演示+代碼的形式系統地總結十大經典排序算法。

排序算法

算法分類 ????十種常見排序算法可以分為兩大類：

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

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

算法復雜度

冒泡排序

????算法思想：

比較相鄰的元素。如果第一個比第二個大，就交換它們兩個

對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最后一對，這樣在最后的元素應該會是最大的數；

針對所有的元素重復以上的步驟，除了最后一個；

重復步驟1~3，直到排序完成。

????代碼：

void bubbleSort(int a[], int n)
{
  for(int i =0 ; i< n-1; ++i)
  {
    for(int j = 0; j < n-i-1; ++j)
    {
      if(a[j] > a[j+1])
      {
        int tmp = a[j] ;  //交換
        a[j] = a[j+1] ;
        a[j+1] = tmp;
      }
    }
  }
}

?

選擇排序

????算法思想：

在未排序序列中找到最小（大）元素，存放到排序序列的起始位置

從剩余未排序元素中繼續尋找最小（大）元素，然后放到已排序序列的末

以此類推，直到所有元素均排序完畢

????代碼：

void selectionSort(int arr[], int n) {
    int minIndex, temp;
    for (int i = 0; i < n - 1; i++) {
        minIndex = i;
        for (var j = i + 1; j < n; j++) {
            if (arr[j] < arr[minIndex]) {     // 尋找最小的數
                minIndex = j;                 // 將最小數的索引保存
            }
        }
        temp = arr[i];
        arr[i] = arr[minIndex];
        arr[minIndex] = temp;
    }
    for (int k = 0; i < n; i++) {
        printf("%d ", arr[k]);
    }
}

?

插入排序

????算法思想：

從第一個元素開始，該元素可以認為已經被排序；

取出下一個元素，在已經排序的元素序列中從后向前掃描；

如果該元素（已排序）大于新元素，將該元素移到下一位置；

重復步驟3，直到找到已排序的元素小于或者等于新元素的位置；

將新元素插入到該位置后；

重復步驟2~5。

????代碼：

void print(int a[], int n ,int i){
  cout<
? ????算法分析： ????插入排序在實現上，通常采用in-place排序（即只需用到O(1)的額外空間的排序），因而在從后向前掃描過程中，需要反復把已排序元素逐步向后挪位，為最新元素提供插入空間。

	?

	快速排序

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

	選取第一個數為基準

	將比基準小的數交換到前面，比基準大的數交換到后面

	遞歸地（recursive）把小于基準值元素的子數列和大于基準值元素的子數列排序

	 ????代碼：

void QuickSort(vector& v, int low, int high) {
    if (low >= high)  // 結束標志
        return;
    int first = low;  // 低位下標
    int last = high;  // 高位下標
    int key = v[first];  // 設第一個為基準


    while (first < last)
    {
        // 將比第一個小的移到前面
        while (first < last && v[last] >= key)
            last--;
        if (first < last)
            v[first++] = v[last];


        // 將比第一個大的移到后面
        while (first < last && v[first] <= key)
            first++;
        if (first < last)
            v[last--] = v[first];
    }
    //
    v[first] = key;
    // 前半遞歸
    QuickSort(v, low, first - 1);
    // 后半遞歸
    QuickSort(v, first + 1, high);
}
?

	?

	堆排序

	????堆排序（Heapsort）是指利用堆這種數據結構所設計的一種排序算法。堆積是一個近似完全二叉樹的結構，并同時滿足堆積的性質：即子節點的鍵值或索引總是小于（或者大于）它的父節點。 ????算法思想：

	將初始待排序關鍵字序列(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，則整個排序過程完成。

	????代碼：

#include 
#include 
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[] = { 3, 5, 3, 0, 8, 6, 1, 5, 8, 6, 2, 4, 9, 4, 7, 0, 1, 8, 9, 7, 3, 1, 2, 5, 9, 7, 4, 0, 2, 6 };
    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;
}
?

	?

	歸并排序

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

	把長度為n的輸入序列分成兩個長度為n/2的子序列；

	對這兩個子序列分別采用歸并排序；

	將兩個排序好的子序列合并成一個最終的排序序列。

	 ????代碼：

void print(int a[], int n){
  for(int j= 0; j
?

	?

	希爾排序

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

	選擇一個增量序列t1，t2，…，tk，其中ti>tj，tk=1；

	按增量序列個數k，對序列進行k 趟排序；

	每趟排序，根據對應的增量ti，將待排序列分割成若干長度為m 的子序列，分別對各子表進行直接插入排序。僅增量因子為1 時，整個序列作為一個表來處理，表長度即為整個序列的長度。

	 ????代碼：

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;
    }
}
?

	?

	計數排序

	????計數排序不是基于比較的排序算法，其核心在于將輸入的數據值轉化為鍵存儲在額外開辟的數組空間中。作為一種線性時間復雜度的排序，計數排序要求輸入的數據必須是有確定范圍的整數。 ????算法思想：

	找出待排序的數組中最大和最小的元素；

	統計數組中每個值為i的元素出現的次數，存入數組C的第i項；

	對所有的計數累加（從C中的第一個元素開始，每一項和前一項相加）；

	反向填充目標數組：將每個元素i放在新數組的第C(i)項，每放一個元素就將C(i)減去1。

	 ????代碼：

#include 
#include 
#include 


using namespace std;


// 計數排序
void CountSort(vector& vecRaw, vector& vecObj)
{
    // 確保待排序容器非空
    if (vecRaw.size() == 0)
        return;


    // 使用 vecRaw 的最大值 + 1 作為計數容器 countVec 的大小
    int vecCountLength = (*max_element(begin(vecRaw), end(vecRaw))) + 1;
    vector vecCount(vecCountLength, 0);


    // 統計每個鍵值出現的次數
    for (int i = 0; i < vecRaw.size(); i++)
        vecCount[vecRaw[i]]++;
    
    // 后面的鍵值出現的位置為前面所有鍵值出現的次數之和
    for (int i = 1; i < vecCountLength; i++)
        vecCount[i] += vecCount[i - 1];


    // 將鍵值放到目標位置
    for (int i = vecRaw.size(); i > 0; i--) // 此處逆序是為了保持相同鍵值的穩定性
        vecObj[--vecCount[vecRaw[i - 1]]] = vecRaw[i - 1];
}


int main()
{
    vector vecRaw = { 0,5,7,9,6,3,4,5,2,8,6,9,2,1 };
    vector vecObj(vecRaw.size(), 0);


    CountSort(vecRaw, vecObj);


    for (int i = 0; i < vecObj.size(); ++i)
        cout << vecObj[i] << "  ";
    cout << endl;


    return 0;
}
?

	?

	桶排序

	????將值為i的元素放入i號桶，最后依次把桶里的元素倒出來。 ????算法思想：

	設置一個定量的數組當作空桶子。

	尋訪序列，并且把項目一個一個放到對應的桶子去。

	對每個不是空的桶子進行排序。

	從不是空的桶子里把項目再放回原來的序列中。

	 ????代碼：

void Bucket_Sort(int a[], int n, int max) {
    int i, j=0;
    int *buckets = (int*)malloc((max+1)*sizeof(int));
    // 將buckets中的所有數據都初始化為0
    memset(buckets, 0, (max+1) * sizeof(int));
    // 1.計數
    for (i = 0; i < n; i++) {
        buckets[a[i]]++;
        printf("%d : %d
", a[i], buckets[a[i]]);
    }
    printf("
");
    // 2.排序
    for (i = 0; i < max+1; i++) {
        while ((buckets[i]--) > 0) {
            a[j++] = i;
        }
    }
}
 
int main() {
    int arr[] = { 9,5,1,6,2,3,0,4,8,7 };
    Bucket_Sort(arr, 10,9);
    for (int i = 0; i < 10; i++) {
        printf("%d ", arr[i]);
    }
    printf("
");
 
    return 0;
}
?

	?

	基數排序

	????一種多關鍵字的排序算法，可用桶排序實現。 ????算法思想：

	取得數組中的最大數，并取得位數；

	arr為原始數組，從最低位開始取每個位組成radix數組；

	對radix進行計數排序（利用計數排序適用于小范圍數的特點）

	 ????代碼：

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;
}
?

	?

	　　審核編輯：湯梓紅