文章目錄

• • • 一、排序的概念及應(yīng)用
    • • 💦 排序的概念
      • 💦 排序的運(yùn)用
      • 💦 常見的排序算法
    • 二、常見排序算法的實(shí)現(xiàn)
    • • 💦 插入排序
      • • 1、直接插入排序
        • 2、希爾排序
      • 💦 選擇排序
      • • 1、直接選擇排序
        • 2、堆排序
      • 💦 交換排序
      • • 1、冒泡排序
        • 2、快速排序
      • 💦 歸并排序
      • 💦 非比較排序
      • • 1、計(jì)數(shù)排序
        • 2、基數(shù)排序
      • 💦 文件排序 (拓展)
      • 💦 性能測試
    • 三、排序算法復(fù)雜度及穩(wěn)定性分析
    • 四、概念選擇題

一、排序的概念及應(yīng)用

💦 排序的概念

排序：所謂排序，就是使一串記錄，按照其中的某個(gè)或某些關(guān)鍵字的大小，遞增或遞減的排列起來的操作。

穩(wěn)定性：假定在待排序的記錄序列中，存在多個(gè)具有相同的關(guān)鍵字的記錄，若經(jīng)過排序，這些記錄的相對次
序保持不變，即在原序列中，r[i]=r[j]，且 r[i] 在 r[j] 之前，而在排序后的序列中，r[i] 仍在 r[j] 之前，則稱這種排
序算法是穩(wěn)定的；否則稱為不穩(wěn)定的。

內(nèi)部排序：數(shù)據(jù)元素全部放在內(nèi)存中的排序。

外部排序：數(shù)據(jù)元素太多不能同時(shí)放在內(nèi)存中，根據(jù)排序過程的要求不能在內(nèi)外存之間移動(dòng)數(shù)據(jù)的排序。

數(shù)據(jù)結(jié)構(gòu)和算法動(dòng)態(tài)可視化

💦 排序的運(yùn)用

? 現(xiàn)實(shí)中排序的運(yùn)用非常廣泛，無處不在 ?

好一個(gè)凡爾賽

💦 常見的排序算法

二、常見排序算法的實(shí)現(xiàn)

// 排序?qū)崿F(xiàn)的接口// 插入排序 void InsertSort(int* a, int n);// 希爾排序 void ShellSort(int* a, int n);// 選擇排序 void SelectSort(int* a, int n);// 堆排序 void AdjustDwon(int* a, int n, int root); void HeapSort(int* a, int n);// 冒泡排序 void BubbleSort(int* a, int n)// 快速排序遞歸實(shí)現(xiàn) // 快速排序hoare版本 int PartSort1(int* a, int left, int right); // 快速排序挖坑法 int PartSort2(int* a, int left, int right); // 快速排序前后指針法 int PartSort3(int* a, int left, int right); void QuickSort(int* a, int left, int right);// 快速排序 非遞歸實(shí)現(xiàn) void QuickSortNonR(int* a, int left, int right)// 歸并排序遞歸實(shí)現(xiàn) void MergeSort(int* a, int n) // 歸并排序非遞歸實(shí)現(xiàn) void MergeSortNonR(int* a, int n)// 計(jì)數(shù)排序 void CountSort(int* a, int n); }

💦 插入排序

1、直接插入排序

🔑 核心思想 🔑

??把待排序的記錄按關(guān)鍵碼的大小逐個(gè)插入到一個(gè)已經(jīng)排好的序的有序序列中，直到所有的記錄插入完為止，得到一個(gè)新的有序序列

實(shí)際中我們玩撲克牌時(shí)，就用了插入排序的思想

? 過程：?

當(dāng)插入第 i(i>=1) 個(gè)元素時(shí)，前面的 array[0]， array[1]， … ， array[i-1] 已經(jīng)排好序，此時(shí)用 array[i] 的排序碼與 array[i-1]， array[i-2]，… 的排序碼順序進(jìn)行比較，找到插入位置即將 array[i] 插入，原來位置上的元素順序后移

? 直接插入排序的特性總結(jié)：?

??1?? 元素集合越接近有序，直接插入排序算法的時(shí)間效率越高

??2?? 時(shí)間復(fù)雜度：O(N^2)

??3?? 空間復(fù)雜度：O(1)，它是一種穩(wěn)定的排序算法

??4?? 穩(wěn)定性：穩(wěn)定

? 動(dòng)圖演示：?

🧿 實(shí)現(xiàn)代碼 ：

void InserSort(int* a, int n) {//多趟控制int i = 0;for (i = 0; i < n - 1; i++){//單趟控制int end = i ;int temp = a[end + 1];while (end >= 0){//目標(biāo)數(shù)小于其它數(shù)時(shí)，其它數(shù)就往后挪；大于則插入if (temp < a[end]){a[end + 1] = a[end];end--;}else{break;}}a[end + 1] = temp;} }

? 插入排序的時(shí)間復(fù)雜度 ?

??最壞的情況 - 逆序：O(N²)

??最好的情況 - 接近有序 ：O(N)

2、希爾排序

希爾排序 (縮小增量排序)

🔑 核心思想 🔑

??希爾排序法又稱縮小增量法。希爾排序法的基本思想是：先選定一個(gè)整數(shù)，把待排序文件中所有記錄分成若干個(gè)組，所有距離為 gap 的記錄分在同一組內(nèi)，并對每一組內(nèi)的記錄進(jìn)行排序。然后，取，重復(fù)上述分組和排序的工## 標(biāo)題作。當(dāng)?shù)竭_(dá) = 1 時(shí)，所有記錄在統(tǒng)一組內(nèi)排好序。

??人話就是：

????1?? 預(yù)排序 (接近升序) - gap > 1

????2?? 直接插入排序 - gap == 1

? 希爾排序特性總結(jié) ?

??1?? 希爾排序是對直接插入排序的優(yōu)化

??2?? 當(dāng) gap > 1 時(shí)都是預(yù)排序，目的是讓數(shù)組更接近于有序。當(dāng) gap == 1 時(shí)，其實(shí)就是直接插入排序，且數(shù)組已經(jīng)接近有序的了。整體而言，可以達(dá)到優(yōu)化的效果，我們實(shí)現(xiàn)后可以進(jìn)行性能測試的對比

??3?? 希爾排序的時(shí)間復(fù)雜度并不好計(jì)算，因?yàn)?gap 的取值方法很多，導(dǎo)致很難去計(jì)算，因此在好些數(shù)中給出的希爾排序的時(shí)間復(fù)雜度都不固定，官方給出的時(shí)間復(fù)雜度是 O(N^1.3)

??4?? 穩(wěn)定性：不穩(wěn)定

👁?🗨 知識(shí)擴(kuò)展

🧿 實(shí)現(xiàn)代碼 ：

代碼的核心并不是一組一組的排，而是多組并排

以下只是預(yù)排序代碼，還需要再調(diào)用 InsertSort 進(jìn)行直接插入排序

void ShellSort(int* a, int n) {int i = 0;int gap = 3;//多組并排for (i = 0; i < n - gap; i++){int end = i;int temp = a[end + gap];while (end >= 0){if (temp < a[end]){a[end + gap] = a[end];end -= gap;}else{break;}}a[end + gap] = temp;} }

? 對于 gap 的值寫成固定的并不好 ?

??這里只是建議

void ShellSortPro(int* a, int n) {//gap > 1 預(yù)排序//gap == 1 直接插入排序int i = 0;//gap的初始值為nint gap = n;while (gap > 1){//每次循環(huán)gap都在減少，直到gap變成1gap = gap / 3 + 1;//gap /= 2;for (i = 0; i < n - gap; i++){int end = i;int temp = a[end + gap];while (end >= 0){if (temp < a[end]){a[end + gap] = a[end];end -= gap;}else{break;}}a[end + gap] = temp;}} }

💦 選擇排序

1、直接選擇排序

🔑 核心思想 🔑

??每一次從待排序的數(shù)據(jù)元素中選出最小（或最大）的一個(gè)元素，存放在序列的起始位置，直到全部待排序的數(shù)據(jù)元素排完 。

? 過程：?

??1?? 在元素集合 array[i] - array[n-1] 中選擇關(guān)鍵碼最大 (小) 的數(shù)據(jù)元素

??2?? 若它不是這組元素中的最后一個(gè)(第一個(gè))元素，則將它與這組元素中的最后一個(gè)（第一個(gè)）元素交換

??3?? 在剩余的 array[i] - array[n-2] (array[i+1]–array[n-1]) 集合中，重復(fù)上述步驟，直到集合剩余 1 個(gè)元素

? 直接選擇排序的特性總結(jié)：?

??1?? 直接選擇排序思考非常好理解，但是效率不是很好。實(shí)際中很少使用

??2?? 時(shí)間復(fù)雜度：O(N^2) - 最好 / 最壞

??3?? 空間復(fù)雜度：O(1)

??4?? 穩(wěn)定性：不穩(wěn)定

? 動(dòng)圖演示：?

🧿 實(shí)現(xiàn)代碼 ：

void Swap(int* px, int* py) {int temp = *px;*px = *py;*py = temp; } void SelectSort(int* a, int n) {int i = 0;int begin = 0;while (begin < n){int mini = begin;//選最小for (i = begin; i < n; i++){if (a[i] < a[mini]){mini = i;}}//交換Swap(&a[begin], &a[mini]);//迭代begin++;} }

🧿 實(shí)現(xiàn) SelectSort 的優(yōu)化代碼 ：

?? 遍厲一遍選出最小的和最大的，然后把最小的放在左邊，最大的放在右邊

void Swap(int* px, int* py) {int temp = *px;*px = *py;*py = temp; } void SelectSortPro(int* a, int n) {int i = 0;int begin = 0, end = n - 1;while (begin < end){//選最大和最小int mini = begin, maxi = begin;for (i = begin; i <= end; i++){if (a[i] > a[maxi]){maxi = i;}if (a[i] < a[mini]){mini = i;}}//交換Swap(&a[begin], &a[mini]);//當(dāng)a數(shù)組里第1個(gè)元素是最大值時(shí)，此時(shí)經(jīng)過上面的Swap，最大值的位置已經(jīng)更改了，所以需要修正最大值的位置，讓下一個(gè)Swap正確交換if (begin == maxi){maxi = mini;}Swap(&a[end], &a[maxi]);//迭代++begin;--end;} }

2、堆排序

🔑 核心思想 🔑

??堆排序 (Heapsort) 是指利用堆積樹 (堆) 這種數(shù)據(jù)結(jié)構(gòu)所設(shè)計(jì)的一種排序算法，它是選擇排序的一種。它是通過堆來進(jìn)行選擇數(shù)據(jù)。需要注意的是排升序要建大堆，排降序建小堆。
??關(guān)于堆排序詳解請轉(zhuǎn)到 ? 僅不到五萬字輕松了解二叉樹和堆

? 堆排序的特性總結(jié)：?

??1?? 堆排序使用堆來選數(shù)，效率就高了很多。

??2?? 時(shí)間復(fù)雜度：O(N*logN)

??3?? 空間復(fù)雜度：O(1)

??4?? 穩(wěn)定性：不穩(wěn)定

? 動(dòng)圖演示：?

🧿 實(shí)現(xiàn)代碼 ：

void Swap(int* px, int* py) {int temp = *px;*px = *py;*py = temp; } void AdjustDown(int* a, int n, int parent) {int child = parent * 2 + 1;while (child < n){if (a[child] < a[child + 1] && child + 1 < n){ child++;}if (a[child] > a[parent]){Swap(&a[child], &a[parent]);parent = child;child = parent * 2 + 1;}else{break;}} } void HeapSort(int* a, int n) {//建大堆int i = 0;for (i = (n - 1 - 1) / 2; i >= 0; i--){AdjustDown(a, n, i);}int end = n - 1;//交換并調(diào)整while (end > 0){Swap(&a[0], &a[end]);AdjustDown(a, end, 0);end--;} }

💦 交換排序

1、冒泡排序

🔑 核心思想 🔑

??所謂交換，就是根據(jù)序列中兩個(gè)記錄鍵值的比較結(jié)果來對換這兩個(gè)記錄在序列中的位置，交換排序的特點(diǎn)是：將鍵值較大的記錄向序列的尾部移動(dòng)，鍵值較小的記錄向序列的前部移動(dòng)。

? 冒泡排序的特性總結(jié)：?

??1?? 冒泡排序是一種非常容易理解的排序

??2?? 時(shí)間復(fù)雜度：O(N^2)

??3?? 空間復(fù)雜度：O(1)

??4?? 穩(wěn)定性：穩(wěn)定

? 動(dòng)圖演示：?

🧿 實(shí)現(xiàn)代碼 ：

void Swap(int* px, int* py) {int temp = *px;*px = *py;*py = temp; } void BubbleSort(int* a, int n) {int i = 0;int j = 0;for (i = 0; i < n - 1; i++){for (j = 0; j < n - 1 - i; j++){if (a[j] > a[j + 1]){Swap(&a[j], &a[j + 1]);}}} }

🧿 實(shí)現(xiàn)代碼 BubbleSort 的優(yōu)化版本 ：

?? 當(dāng)遍厲一遍后發(fā)現(xiàn)沒有 Swap 時(shí)，那么說數(shù)組就是有序的

?? 時(shí)間復(fù)雜度：最壞 O(N²)

???????? 最好 O(N)

void Swap(int* px, int* py) {int temp = *px;*px = *py;*py = temp; } void BubbleSortPro(int* a, int n) {int i = 0;int j = 0;for (i = 0; i < n - 1; i++){int flag = 1;for (j = 0; j < n - 1 - i; j++){if (a[j] > a[j + 1]){flag = 0;Swap(&a[j], &a[j + 1]);}}//如果flag等于1說明此時(shí)數(shù)組是升序if (flag == 1)break;} }

2、快速排序

🔑 核心思想 🔑

??快速排序是Hoare于1962年提出的一種二叉樹結(jié)構(gòu)的交換排序方法，其基本思想為：任取待排序元素序列中的某元素作為基準(zhǔn)值，按照該排序碼將待排序集合分割成兩子序列，左子序列中所有元素均小于基準(zhǔn)值，右子序列中所有元素均大于基準(zhǔn)值，然后最左右子序列重復(fù)該過程，直到所有元素都排列在相應(yīng)位置上為止。

? 過程：?

??1?? 選出一個(gè)關(guān)鍵字 key，一般是頭或者尾

??2?? 經(jīng)過一次單趟后，key 放到了正確的位置，key 左邊的值比 key 小，key 右邊的值比 key 大

??3?? 再讓 key 的左邊區(qū)間有序、key 的右邊區(qū)間有序

? 動(dòng)圖演示：?

?一、首次單趟 (注意這三種方法首次單趟后不一定相同)

???💨 hoare 版本

?? 如何保證相遇位置的值小于 key ?

???💨 挖坑版本

???💨 前后指針法

?二、非首次單趟

🧿 實(shí)現(xiàn)代碼 ：首次 + 非首次 + 遞歸版本

void Swap(int* px, int* py) {int temp = *px;*px = *py;*py = temp; } void PartSortHoare(int* a, int left, int right) {int keyi = left;while(left < right){//左邊作key，右邊先走找小while(a[right] >= a[keyi] && left < right){right--;}//右邊找到小，再找左邊的大while(a[left] <= a[keyi] && left < right){left++;}//交換小大Swap(&a[right], &a[left]);}//交換keySwap(&a[keyi], &a[right]);//返回分割大小的那個(gè)下標(biāo)return left; } int PartSortHole(int* a, int left, int right) {int key = a[left];int hole = left;while (left < right){//右邊找小，填左坑while (left < right && a[right] >= key){right--;}a[hole] = a[right];//填坑hole = right;//新的坑//左邊找大，填右坑while (left < right && a[left] <= key){left++;}a[hole] = a[left];//填坑hole = left;//新的坑}//將key填最后一個(gè)坑a[hole] = key;return hole; } int PartSortPoint(int* a, int left, int right) {int keyi = left;int prev = left;int cur = prev + 1;while (cur <= right){//cur比keyi大時(shí)，prev不會(huì)++；且排除了自己交換自己if (a[cur] < a[keyi] && ++prev != cur){Swap(&a[prev], &a[cur]); }//兩種情況cur都要++cur++;}//交換keyiSwap(&a[keyi], &a[prev]);return prev; } void QuickSort(int* a, int left, int right) {//遞歸的結(jié)束條件if (left >= right){return ;}//keyi拿到分割大小的下標(biāo) - [left, keyi - 1]; [keyi]; [keyi + 1, right]//int keyi = PartSortHoare(a, left, right);//版本1//int keyi = PartSortHole(a, left, right);//版本2int keyi = PartSortPoint(a, left, right);//版本3//遞歸左QuickSort(a, left, keyi - 1);//遞歸右QuickSort(a, keyi + 1, right); }

? QuickSort 的時(shí)間復(fù)雜度 ?

🧿 實(shí)現(xiàn) QuickSort 的優(yōu)化代碼 —— 優(yōu)化有序的情況

??三數(shù)取中選 key —— left、mid、right 中不是最大也不是最小的數(shù)

//三數(shù)取中 int GetMidIndex(int* a, int left, int right) {//int mid = (left + right) / 2;int mid = left + (right - left) / 2;//防止溢出版本if (a[left] < a[mid]){if (a[mid] < a[right]){return mid;}else if (a[left] < a[right]){return right;}else{return left;}}else //a[left] > a[mid]{if (a[mid] > a[right]){return mid;}else if(a[left] < a[right]){return left;}else{return right;}} } int PartSortHoarePro(int* a, int left, int right) {int midi = GetMidIndex(a, left, right);Swap(&a[left], &a[midi]);int keyi = left;while (left < right){while (a[right] >= a[keyi] && left < right){right--;}while (a[left] <= a[keyi] && left < right){ left++;}Swap(&a[right], &a[left]);}Swap(&a[keyi], &a[right]);return left; } int PartSortHolePro(int* a, int left, int right) {int midi = GetMidIndex(a, left, right);Swap(&a[left], &a[midi]);int key = a[left];int hole = left;while (left < right){//右邊找小，填左坑while (left < right && a[right] >= key){right--;}a[hole] = a[right];//填坑hole = right;//新的坑//左邊找大，填右坑while (left < right && a[left] <= key){left++;}a[hole] = a[left];//填坑hole = left;//新的坑}//將key填最后一個(gè)坑a[hole] = key;return hole; } int PartSortPointPro(int* a, int left, int right) {int midi = GetMidIndex(a, left, right);Swap(&a[left], &a[midi]);int keyi = left;int prev = left;int cur = prev + 1;while (cur <= right){//cur比keyi大時(shí)，prev不會(huì)++；且排除了自己交換自己if (a[cur] < a[keyi] && ++prev != cur){Swap(&a[prev], &a[cur]);}//兩種情況cur都要++cur++;}//交換keyiSwap(&a[keyi], &a[prev]);return prev; } void QuickSortPro(int* a, int left, int right) {if (left >= right){return;}//int keyi = PartSortHoarePro(a, left, right);//版本1//int keyi = PartSortHolePro(a, left, right);//版本2int keyi = PartSortPointPro(a, left, right);//版本3QuickSortPro(a, left, keyi - 1);QuickSortPro(a, keyi + 1, right); }

? QuickSortHoarePro 的時(shí)間復(fù)雜度 ?

??這里就不會(huì)出現(xiàn)最壞的情況 —— 有序，因?yàn)橛辛巳龜?shù)取中算法。

?
🧿 實(shí)現(xiàn)代碼 ：首次 + 非首次 + 非遞歸版本

??任何一個(gè)遞歸代碼，要改成非遞歸

???1、循環(huán)

???2、棧 (數(shù)據(jù)結(jié)構(gòu)) 模擬

??顯然這里的快排不好直接改成循環(huán)，還要借助棧，所以這里復(fù)用了之前 C 實(shí)現(xiàn)的棧，詳解請轉(zhuǎn) ? 爆肝兩萬字，我爺爺都看的懂的《棧和隊(duì)列》，建議各位觀眾姥爺先收藏

🔑 核心思想 🔑

void QuickSortNonR(int* a, int left, int right) {ST st;StackInit(&st);//先入第一組區(qū)間StackPush(&st, right);StackPush(&st, left);//棧不為空while (!StackEmpty(&st)){//取棧頂left，并Popint begin = StackTop(&st);StackPop(&st);//再取棧頂right，并Popint end = StackTop(&st);StackPop(&st);//這里就用前后指針版本進(jìn)行單趟排int keyi = PartSortPointPro(a, begin, end);//再入?yún)^(qū)間 [left, keyi - 1]; [keyi]; [keyi + 1, end]//右區(qū)間 —— 只有1個(gè)值不會(huì)入if (keyi + 1 < end){StackPush(&st, end);StackPush(&st, keyi + 1);}//左區(qū)間 —— 只有1個(gè)值不會(huì)入if (begin < keyi - 1){StackPush(&st, keyi - 1);StackPush(&st, begin);}}StackDestory(&st); }

? 快速排序的特性總結(jié)：?

??1?? 快速排序整體的綜合性能和使用場景都是比較好的，所以才敢叫快速排序

??2?? 時(shí)間復(fù)雜度：O(N*logN)

??3?? 空間復(fù)雜度：O(logN)

??4?? 穩(wěn)定性：不穩(wěn)定

💦 歸并排序

🔑 核心思想 🔑

??歸并排序 (MERGE-SORT) 是建立在歸并操作上的一種有效的排序算法，該算法是采用分治法 (Divide and Conquer) 的一個(gè)非常典型的應(yīng)用。將已有序的子序列合并，得到完全有序的序列；即先使每個(gè)子序列有序，再使子序列有序。若將兩個(gè)有序表合并成一個(gè)有序表，稱為二路歸并。

??歸并排序核心步驟：

? 動(dòng)圖演示：?

🧿 實(shí)現(xiàn)代碼 —— 遞歸版 ：

void _MergeSort(int* a, int left, int right, int* temp) {//只有一個(gè)值if (left >= right)return;//[left, mid][mid+1, right]int mid = (right + left) / 2;//遞歸_MergeSort(a, left, mid, temp);_MergeSort(a, mid + 1, right, temp);//歸并到tempint begin1 = left, end1 = mid;int begin2 = mid + 1, end2 = right;//&&其中一段區(qū)間結(jié)束就結(jié)束了int index = left;while (begin1 <= end1 && begin2 <= end2){if (a[begin1] < a[begin2]){temp[index++] = a[begin1++];}else{temp[index++] = a[begin2++];}}//begin2結(jié)束了，拷貝剩下的begin1while (begin1 <= end1){temp[index++] = a[begin1++];}//begin1結(jié)束了，拷貝剩下的begin2while (begin2 <= end2){temp[index++] = a[begin2++];}//歸并后的結(jié)果，拷貝至原數(shù)組int i = 0;for (i = left; i <= right; i++){a[i] = temp[i];} } void MergeSort(int* a, int n) {//臨時(shí)數(shù)組 int* temp = (int*)malloc(sizeof(int) * n);//子函數(shù)遞歸_MergeSort(a, 0, n - 1, temp);//釋放臨時(shí)數(shù)組free(temp); }

🧿 實(shí)現(xiàn)代碼 —— 非遞歸版 ：

🔑 核心思想 🔑

void MergeSortNonR(int* a, int n) {//臨時(shí)數(shù)組 int* temp = (int*)malloc(sizeof(int) * n);int groupNum = 1;int i = 0; while (groupNum < n){for (i = 0; i < n; i += 2 * groupNum){//[begin1, end1][begin2, end2]int begin1 = i, end1 = i + groupNum - 1;int begin2 = i + groupNum, end2 = i + groupNum * 2 - 1;//歸并int index = begin1;//數(shù)組的數(shù)據(jù)個(gè)數(shù)，并不一定是按整數(shù)倍，所以分組可能越界或不存在//1.[begin2,end2]不存在或越界，修正為一個(gè)不存在的區(qū)間if (begin2 >= n){begin2 = n + 1;end2 = n;}//2.end1越界，修正后歸并if (end1 >= n){end1 = n - 1;}//3.end2越界，修正后歸并if (end2 >= n){end2 = n - 1;}while (begin1 <= end1 && begin2 <= end2){if (a[begin1] < a[begin2]){temp[index++] = a[begin1++];}else{temp[index++] = a[begin2++];}}//begin2結(jié)束了，拷貝剩下的begin1while (begin1 <= end1){temp[index++] = a[begin1++];}//begin1結(jié)束了，拷貝剩下的begin2while (begin2 <= end2){temp[index++] = a[begin2++];}}//拷貝回原數(shù)組for (i = 0; i < n; i++){a[i] = temp[i];}//迭代groupNum *= 2;//輸出每層//PrintArray(a, n);}//釋放臨時(shí)數(shù)組free(temp); }

? 歸并排序的特性總結(jié)：?

??1?? 歸并的缺點(diǎn)在于需要O(N)的空間復(fù)雜度，歸并排序的思考更多的是解決在磁盤中的外排序問題

??2?? 時(shí)間復(fù)雜度：O(N*logN)

??3?? 空間復(fù)雜度：O(N)

??4?? 穩(wěn)定性：穩(wěn)定

💦 非比較排序

1、計(jì)數(shù)排序

🔑 核心思想 🔑

??計(jì)數(shù)排序又稱為鴿巢原理，是對哈希直接定址法的變形應(yīng)用。

??計(jì)數(shù)排序核心步驟：

???1?? 統(tǒng)計(jì)相同元素出現(xiàn)次數(shù)

???2?? 根據(jù)統(tǒng)計(jì)的結(jié)果將序列回收到原來的序列中

? 動(dòng)圖演示：?

🧿 實(shí)現(xiàn)代碼 ：

void CountSort(int* a, int n) {//遍厲一遍找出最小值和最大值int min = a[0], max = a[0];int i = 0;for (i = 1; i < n; i++){if (a[i] < min){min = a[i];}if (a[i] > max){max = a[i];}}//求出這個(gè)區(qū)間 int range = max - min + 1;//calloc空間，并初始化為0 int* count = (int*)calloc(range, sizeof(int));//統(tǒng)計(jì) for (i = 0; i < n; i++){//相對位置count[a[i] - min]++;}//根據(jù)count數(shù)組排序i = 0; int j = 0; for (j = 0; j < range; j++){while (count[j]--) {a[i++] = j + min;}}free(count); }

? 計(jì)數(shù)排序的特性總結(jié)：?

??1?? 計(jì)數(shù)排序在數(shù)據(jù)范圍集中時(shí)，效率很高，但是適用范圍及場景有限

??2?? 時(shí)間復(fù)雜度：O(MAX(N,范圍))

??3?? 空間復(fù)雜度：O(范圍)

??4?? 穩(wěn)定性：穩(wěn)定

??5?? 只適合整數(shù)排序，浮點(diǎn)數(shù)/字符串不能排

2、基數(shù)排序

🔑 核心思想 🔑

??基數(shù)排序又稱桶排序，它分別按數(shù)據(jù)的個(gè)、十、百、千、萬 … 排序，當(dāng)然也可以先萬、千、…

? 動(dòng)圖演示：?

? 這里就不實(shí)現(xiàn)了，為什么 ?

??因?yàn)檫@種排序?qū)嶋H在校招中和現(xiàn)實(shí)中已經(jīng)很少使用了，各位碼友有興趣的也可以自己了解下

💦 文件排序 (拓展)

? 注意

??小文件排序是沒有意義的，當(dāng)然我們這里只是模擬，所以給 100 個(gè)數(shù)據(jù)

🔑 核心思想 🔑

??磁盤的讀取速度相比內(nèi)存差距非常大，所以我們不可能像在內(nèi)存中兩兩歸并。正確的歸并方法是大文件平均分割成 N 份，保證每份大小都可以加載到內(nèi)存，那么就可以把每個(gè)小文件加載到內(nèi)存中，使用快排排序，再寫回小文件，這時(shí)就達(dá)到文件中歸并的先決條件

🧿 實(shí)現(xiàn)代碼 ：

void _MergeFile(const char* File1, const char* File2, const char* mFile) {//讀文件1FILE* fout1 = fopen(File1, "r");if (fout1 == NULL){printf("打開文件失敗\n");exit(-1);}//讀文件2FILE* fout2 = fopen(File2, "r");if (fout2 == NULL){printf("打開文件失敗\n");exit(-1);}//寫文件3,把文件1和文件2寫到文件3里FILE* fin = fopen(mFile, "w");if (fin == NULL){printf("打開文件失敗\n");exit(-1);}int num1, num2;//對于內(nèi)存中沒有問題，但是磁盤就有問題了。不管num1和num2誰小誰大，只要讀了fout1和fout2它們都會(huì)往后走/*while (fscanf(fout1, "%d\n", &num1) != EOF && fscanf(fout2, "%d\n", &num2) != EOF){if (num1 < num2)fprintf(fin, "%d\n", num1);elsefprintf(fin, "%d\n", num2);}*/int ret1 = fscanf(fout1, "%d\n", &num1);int ret2 = fscanf(fout2, "%d\n", &num2);//下面保證了誰讀誰走；fout1和fout2都不為空再比較while (ret1 != EOF && ret2 != EOF){if (num1 < num2){fprintf(fin, "%d\n", num1);ret1 = fscanf(fout1, "%d\n", &num1);//更新字符}else{fprintf(fin, "%d\n", num2);ret2 = fscanf(fout2, "%d\n", &num2); //更新字符}}/*注意這樣會(huì)導(dǎo)致少寫一個(gè)數(shù)據(jù)//fout2完了，寫剩下的fout1while (fscanf(fout1, "%d\n", &num1) != EOF){fprintf(fin, "%d\n", num1);}//fout1完了，寫剩下的fout2while (fscanf(fout2, "%d\n", &num2) != EOF){fprintf(fin, "%d\n", num2);}*///fout2完了，寫剩下的fout1while (ret1 != EOF){fprintf(fin, "%d\n", num1);ret1 = fscanf(fout1, "%d\n", &num1);//更新字符}//fout1完了，寫剩下的fout2while (ret2 != EOF){fprintf(fin, "%d\n", num2);ret2 = fscanf(fout2, "%d\n", &num2); //更新字符}//關(guān)閉文件 fclose(fout1);fclose(fout2);fclose(fin); } void MergeSortFile(const char* file) {FILE* fout = fopen(file, "r");if (fout == NULL){printf("打開文件失敗\n");exit(-1);}int n = 10;int a[10];int i = 0;int num = 0;char subfile[20];int filei = 1;memset(a, 0, sizeof(int) * n);//從fout文件流里讀，直至EOFwhile (fscanf(fout, "%d\n", &num) != EOF){//每次循環(huán)讀10個(gè)數(shù)據(jù)放在內(nèi)存中(if里先放9個(gè)，else再放最后一個(gè))if (i < n - 1){a[i++] = num;}else{a[i] = num;//快排10個(gè)數(shù)據(jù)QuickSort(a, 0, n - 1);//生成文件名sub_sort1/2/3...sprintf(subfile, "%d", filei++);//寫文件，subfile里存儲(chǔ)生成的文件名FILE* fin = fopen(subfile, "w");if (fin == NULL){printf("打開文件失敗\n");exit(-1);}//寫回小文件for (int i = 0; i < n; i++){fprintf(fin, "%d\n", a[i]);}//關(guān)閉文件fclose(fin);//重置ii = 0;memset(a, 0, sizeof(int) * n);}}//互相歸并到文件，實(shí)現(xiàn)整體有序char mFile[100] = "12";char File1[100] = "1";char File2[100] = "2";for (i = 2; i <= n; i++){//讀取File1和File2，歸并出mFile_MergeFile(File1, File2, mFile);//拷貝迭代File1的文件名12/123/1234...strcpy(File1, mFile);//循環(huán)迭代File2的文件名3/4/5...sprintf(File2, "%d", i + 1);//循環(huán)迭代mFile的文件名123/1234/12345...sprintf(mFile, "%s%d",mFile, i + 1);}//關(guān)閉文件fclose(fout); }

💦 性能測試

? 測試所有排序 && 怎么保證它是公平的 ?

??數(shù)組里放的數(shù)據(jù)都是一樣的

//測試排序的性能對比 void TestOP() {srand(time(0));const int N = 100000;int* a1 = (int*)malloc(sizeof(int) * N);int* a2 = (int*)malloc(sizeof(int) * N);int* a3 = (int*)malloc(sizeof(int) * N);int* a4 = (int*)malloc(sizeof(int) * N);int* a5 = (int*)malloc(sizeof(int) * N);int* a6 = (int*)malloc(sizeof(int) * N);int* a7 = (int*)malloc(sizeof(int) * N);int* a8 = (int*)malloc(sizeof(int) * N);int* a9 = (int*)malloc(sizeof(int) * N);int* a10 = (int*)malloc(sizeof(int) * N);int* a11 = (int*)malloc(sizeof(int) * N);int* a12 = (int*)malloc(sizeof(int) * N);for (int i = 0; i < N; i++){a1[i] = rand();a2[i] = a1[i];a3[i] = a1[i];a4[i] = a1[i]; a5[i] = a1[i];a6[i] = a1[i];a7[i] = a1[i];a8[i] = a1[i];a9[i] = a1[i];a10[i] = a1[i];a11[i] = a1[i];a12[i] = a1[i];}int begin1 = clock();InsertSort(a1, N);int end1 = clock();int begin2 = clock();ShellSort(a2, N);int end2 = clock();int begin2_1 = clock();ShellSortPro(a3, N);int end2_1 = clock();int begin3 = clock();SelectSort(a4, N);int end3 = clock();int begin3_1 = clock();SelectSortPro(a5, N);int end3_1 = clock();int begin4 = clock();HeapSort(a6, N);int end4 = clock();int begin5 = clock();BubbleSort(a6, N);int end5 = clock();int begin5_1 = clock();BubbleSortPro(a7, N);int end5_1 = clock();int begin6 = clock();QuickSort(a8, 0, N - 1);int end6 = clock();int begin6_1 = clock();QuickSortPro(a9, 0, N - 1);int end6_1 = clock();int begin6_2 = clock();QuickSortNonR(a10, 0, N - 1);int end6_2 = clock();int begin7 = clock();MergeSort(a11, N);int end7 = clock();int begin7_1 = clock();MergeSortNonR(a12, N);int end7_1 = clock();printf("InsertSort:%d\n", end1 - begin1);printf("ShellSort:%d\n", end2 - begin2);printf("ShellSortPro:%d\n", end2_1 - begin2_1);printf("SelectSort:%d\n", end3 - begin3);printf("SelectSortPro:%d\n", end3_1 - begin3_1);printf("HeapSort:%d\n", end4 - begin4);printf("BubbleSort:%d\n", end5 - begin5);printf("BubbleSortPro:%d\n", end5_1 - begin5_1);printf("QuickSort:%d\n", end6 - begin6);printf("QuickSortPro:%d\n", end6_1 - begin6_1);printf("QuickSortNonR:%d\n", end6_2 - begin6_2);printf("MergeSort:%d\n", end7 - begin7);printf("MergeSortNonR:%d\n", end7_1 - begin7_1);free(a1);free(a2);free(a3);free(a4);free(a5);free(a6);free(a7);free(a8);free(a9);free(a10);free(a11);free(a12); }

💨 輸出結(jié)果 (這里使用 Release 版本 && 10 萬個(gè)數(shù)據(jù))

??這里測試 3 次

三、排序算法復(fù)雜度及穩(wěn)定性分析

? 穩(wěn)定性 (比較重要，注意不要死記，要結(jié)合思想來看) ?

??假定在待排序的記錄序列中，存在多個(gè)具有相同的關(guān)鍵字的記錄，若經(jīng)過排序，這些記錄的相對次
序保持不變，即在原序列中，r[i]=r[j]，且 r[i] 在 r[j] 之前，而在排序后的序列中，r[i] 仍在 r[j] 之前，則稱這種排
序算法是穩(wěn)定的；否則稱為不穩(wěn)定的。

? 穩(wěn)定性的意義 ?

??假設(shè)有一考試，并規(guī)定前 6 名發(fā)獎(jiǎng)狀，如果分?jǐn)?shù)相同，則按交卷時(shí)間的先后計(jì)算名次。此時(shí)排序穩(wěn)定性的意義就有所體現(xiàn)了

四、概念選擇題

1、快速排序算法是基于 ( ) 的一個(gè)排序算法

A. 分治法

B. 貪心法

C. 遞歸法

D. 動(dòng)態(tài)規(guī)劃法

📝 分析：快速排序是一種分治的算法，其次遞歸不是一種算法

---

2、對記錄（54, 38, 96, 23, 15, 72, 60, 45, 83）進(jìn)行從小到大的直接插入排序時(shí)，當(dāng)把第8個(gè)記錄45插入到有序表時(shí)，為找到插入位置需比較 ( ) 次？（采用從后往前比較）

A. 3

B. 4

C. 5

D. 6

📝 分析：

15?23?38?54?60?72?96?45

所以需要比較 5 次

---

3、以下排序方式中占用 O(n) 輔助存儲(chǔ)空間的是 ( )

A. 簡單排序

B. 快速排序

C. 堆排序

D. 歸并排序

📝 分析：注意沒有簡單排序；歸并排序的空間復(fù)雜度是 O(N)

---

4、下列排序算法中穩(wěn)定且時(shí)間復(fù)雜度為 O(n²) 的是 ( )

A. 快速排序

B. 冒泡排序

C. 直接選擇排序

D. 歸并排序

📝 分析：

冒泡排序是穩(wěn)定的算法，且時(shí)間復(fù)雜度是 O(N²)

直接選擇排序是不穩(wěn)定的，例如：

5?5?1

1?5?5?

---

5、關(guān)于排序，下面說法不正確的是 ( )

A. 快排時(shí)間復(fù)雜度為 O(N*logN)，空間復(fù)雜度為 O(logN)

B. 歸并排序是一種穩(wěn)定的排序，堆排序和快排均不穩(wěn)定

C. 序列基本有序時(shí)，快排退化成冒泡排序，直接插入排序最快

D. 歸并排序空間復(fù)雜度為 O(N)，堆排序空間復(fù)雜度的為 O(logN)

📝 分析：堆排序沒使用遞歸，沒有輔助空間，所以它的空間復(fù)雜度為 O(1)

---

6、下列排序法中，最壞情況下時(shí)間復(fù)雜度最小的是 ( )

A. 堆排序

B. 快速排序

C. 希爾排序

D. 冒泡排序

📝 分析：堆排序 (歸并) 最壞情況下和最好情況下時(shí)間復(fù)雜度最小的 —— O(N*lonN)

---

7、設(shè)一組初始記錄關(guān)鍵字序列為 (65,56,72,99,86,25,34,66)，則以第一個(gè)關(guān)鍵字 65 為基準(zhǔn)而得到的第一趟快速排序結(jié)果是 ( )

A. 34，56，25，65，86，99，72，66

B. 25，34，56，65，99，86，72，66

C. 34，56，25，65，66，99，86，72

D. 34，56，25，65，99，86，72，66

📝 分析：

我們前面已經(jīng)了解到快速排序首次單趟的三種方法 —— hoare版本、挖坑版本、前后指針版本，注意在某些情況下需要都考慮到，因?yàn)槿N版本得到的結(jié)果不一定都一樣

結(jié)合情況此題選擇 A 選項(xiàng)

總結(jié)

以上是生活随笔為你收集整理的数据结构和算法之排序总结的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯(cuò)，歡迎將生活随笔推薦給好友。