2022計(jì)算機(jī)考研408—數(shù)據(jù)結(jié)構(gòu)—排序
手把手教學(xué)考研大綱范圍內(nèi)的排序
22考研大綱數(shù)據(jù)結(jié)構(gòu)要求的是C/C++，筆者以前使用的都是Java，對(duì)于C++還很欠缺，
如有什么建議或者不足歡迎大佬評(píng)論區(qū)或者私信指出

Talk is cheap. Show me the code.
理論到處都有，代碼加例題自己練習(xí)才能真的學(xué)會(huì)

排序過(guò)程步驟顯示

文末投票：下篇22考研數(shù)據(jù)結(jié)構(gòu)的博客寫什么（歡迎評(píng)論區(qū)指出）

排序定義
冒泡排序
直接插入排序
二分插入排序
希爾排序?
快速排序
二路歸并排序?
基數(shù)排序（附加計(jì)數(shù)排序）?
簡(jiǎn)單選擇排序
堆排序??

排序

排序的基本概念

顧名思義，給一個(gè)無(wú)序數(shù)組的值進(jìn)行順序存儲(chǔ)

原數(shù)組：2 3 1 5 6 4 8 9 7 排序后：1 2 3 4 5 6 7 8 9

冒泡排序

思路：
從頭到尾每?jī)蓚€(gè)相鄰的元素，進(jìn)行比較，前面的比后面的大就進(jìn)行交換
循環(huán)一遍后，數(shù)組元素最大的就到了最后面，
第二次循環(huán)的時(shí)候，就可以不循環(huán)到最后一個(gè)了，最后一個(gè)上次循環(huán)已經(jīng)是整個(gè)數(shù)組最大的值了
然后把這次最大的放到倒數(shù)第二個(gè)元素，
第三次循環(huán)的就可以忽略最后兩個(gè)元素
以此類推，全部循環(huán)后，即可完成排序

#include <iostream> #include <vector>using namespace std;void bubbleSort(vector<int> &num); int main() {int n; //n為將要輸入的數(shù)組長(zhǎng)度cin >> n; //輸入n cin方法需要上面使用stdvector<int> num; //定義vector 記得上面導(dǎo)入vectorint temp; //temp為輸入vector時(shí)的中間變量for (int i = 0; i < n; i++) {cin >> temp; //輸入num.push_back(temp);}bubbleSort(num); //調(diào)用自定義的排序方法cout << "排序后" << "\n";for (int i = 0; i < num.size(); i++) {cout << num[i] << " "; //輸出}return 0; }void bubbleSort(vector<int> &num) {for (int i = 0; i < num.size(); i++) {for (int j = 0; j < num.size() - i; j++) {if (num[j] > num[j + 1]) { // int temp = num[j]; // num[j] = num[j + 1]; // num[j + 1] = temp;num[j] ^= num[j + 1]; //兩兩相鄰交換 上面注釋代碼的功能與此功能相等num[j + 1] ^= num[j];num[j] ^= num[j + 1];}}//每次循環(huán)都把數(shù)組的變動(dòng)輸出出來(lái)for (int j = 0; j < num.size(); j++) {cout << num[j] << " ";}cout << "\n";} }

//冒泡排序的變種#include <iostream> #include <vector>using namespace std;void bubbleSort(vector<int> &num); int main() {int n; //n為將要輸入的數(shù)組長(zhǎng)度cin >> n; //輸入n cin方法需要上面使用stdvector<int> num; //定義vector 記得上面導(dǎo)入vectorint temp; //temp為輸入vector時(shí)的中間變量for (int i = 0; i < n; i++) {cin >> temp; //輸入num.push_back(temp);}bubbleSort(num); //調(diào)用自定義的排序方法for (int i = 0; i < num.size(); i++) {cout << num[i] << " "; //輸出}return 0; }void bubbleSort(vector<int> &num) {int flag = 1; //flag用來(lái)判斷，如果本次循環(huán)沒(méi)有進(jìn)行交換，該數(shù)組為有序數(shù)組int arrBoundary = num.size() - 1; //用來(lái)記錄上一次循環(huán)最后一次交換位置，后面沒(méi)有交換的是有序的int largestSwapIndex = 0; //記錄最后一次交換的位置for (int i = 0; i < num.size(); i++) {flag = 1;for (int j = 0; j < arrBoundary ; j++) {if (num[j] > num[j + 1]) {int temp = num[j];num[j] = num[j + 1];num[j + 1] = temp;flag = 0; //發(fā)生交換就改為0largestSwapIndex = j; //交換位置就給largestSwapIndex}}arrBoundary = largestSwapIndex; //把當(dāng)前循環(huán)交換的最后一個(gè)下標(biāo)給arrBoundaryif (flag) { //如果本次循環(huán)沒(méi)有交換任何值，證明當(dāng)前數(shù)組為有序數(shù)組break;}}}

直接插入排序

思路：
插入 == 把數(shù)插進(jìn)去
也是兩層循環(huán)
數(shù)組num

第一層循環(huán)從下標(biāo)為1的值開始，循環(huán)變量為i
第二層循環(huán)就是把第一層的值拿出來(lái)，然后從第i-1個(gè)向前循環(huán)，找到第一個(gè)小于 num[i] 的值，
這個(gè)值的下標(biāo)如果是j-1的話，那么 num[j] 就是第一個(gè)大于 num[i] 的值
把 num[i] 用一個(gè)變量 temp 保存一下
把下標(biāo)為j到i-1的值依次向后移動(dòng)一位，也就是說(shuō)下標(biāo)j到i-1的值移動(dòng)到j(luò)+1到i，
然后把 temp(原num[i])放到下標(biāo)為j的地方（之前的num[j]已經(jīng)移動(dòng)到num[j+1]了），

按照這種排序，每次循環(huán)的都是i之前的，i之前的元素都是順序存儲(chǔ)的，
文字表述的不清楚的可以看每次循環(huán)i更改后數(shù)組的元素情況

#include <iostream> #include <vector>using namespace std;void insertSort(vector<int> &num); int main() {int n; //n為將要輸入的數(shù)組長(zhǎng)度cin >> n; //輸入n cin方法需要上面使用stdvector<int> num; //定義vector 記得上面導(dǎo)入vectorint temp; //temp為輸入vector時(shí)的中間變量for (int i = 0; i < n; i++) {cin >> temp; //輸入num.push_back(temp);}insertSort(num); //調(diào)用自定義的排序方法cout << "排序后" << "\n";for (int i = 0; i < num.size(); i++) {cout << num[i] << " "; //輸出}return 0; }void insertSort(vector<int> &num) {for (int i = 1; i < num.size(); i++) {int temp = num[i]; //保存一下num[i]int j;//從num[j]向前開始找，一直找到比temp(原num[i])小的數(shù)就結(jié)束//在循環(huán)過(guò)程中的數(shù)都比temp大的，不斷地把temp大的數(shù)往后移動(dòng)一位//由此可得，等找到num[j]<=temp的時(shí)候，循環(huán)已經(jīng)結(jié)束了// 但是他的上一個(gè)，也就是num[j+1]的值已經(jīng)移動(dòng)到num[j+2]了for (j = i - 1; j >= 0 && num[j] > temp; j--) {num[j + 1] = num[j];}//可以直接把temp放到num[j+1]，num[j + 1] = temp;//每次循環(huán)都可以把num[i]以及之前的數(shù)值排序好//每次循環(huán)都把數(shù)組的變動(dòng)輸出出來(lái)for(j = 0; j < num.size(); j++) {cout << num[j] << " ";}cout <<"\n";} }

運(yùn)行截圖：

二分插入排序

思路：
二分插入和簡(jiǎn)單插入基本類似
不過(guò)是在尋找插入位置的時(shí)候不在采用簡(jiǎn)單插入的循環(huán)查找，而是使用二分查找
減少比較的次數(shù)，提升效率

#include <iostream> #include <vector>using namespace std;void binInsertSort(vector<int> &num); int main() {int n; //n為將要輸入的數(shù)組長(zhǎng)度cin >> n; //輸入n cin方法需要上面使用stdvector<int> num; //定義vector 記得上面導(dǎo)入vectorint temp; //temp為輸入vector時(shí)的中間變量for (int i = 0; i < n; i++) {cin >> temp; //輸入num.push_back(temp);}binInsertSort(num); //調(diào)用自定義的排序方法cout << "排序后" << "\n";for (int i = 0; i < num.size(); i++) {cout << num[i] << " "; //輸出}return 0; }void binInsertSort(vector<int> &num) {for (int i = 1; i < num.size(); i++) {int temp = num[i]; //保存臨時(shí)變量int left = 0; //使用二分法找到插入的位置left 使得num[left]<temp<num[left+1]int right = i - 1;while (left <= right) {int mid = (left + right) / 2;if (num[mid] > temp) {right = mid - 1;} else {left = mid + 1;}}for (int j = i - 1; j >= left; j--) {num[j + 1] = num[j]; //把left右面的值全部右移一位，}num[left] = temp; //把temp放到num[left]的位置//每次循環(huán)都把數(shù)組的變動(dòng)輸出出來(lái)for (int j = 0; j < num.size(); j++) {cout << num[j] << " ";}cout << "\n";} }

希爾排序

思路：

希爾排序其實(shí)可以看做是插入排序的變種
插入排序是循環(huán)到某個(gè)元素就像前找合適的位置，把當(dāng)前元素到合適位置的值都要向后移動(dòng)一遍
插入排序?qū)τ谟行虻臄?shù)組，比較和移動(dòng)的次數(shù)都比較少
希爾排序就是把插入排序進(jìn)行分組化

分組是按照長(zhǎng)度每次除2分的，這樣最后一次肯定是一個(gè)組一個(gè)元素，就相當(dāng)于最原始的插入排序了
而他前面做的按組排序就是為了讓這個(gè)數(shù)組變成一個(gè)有大概順序的數(shù)組，使后面的插入排序能減少比較和移動(dòng)的次數(shù)

按下圖為例子，數(shù)組長(zhǎng)度15 第一次按照7個(gè)增量分組，第二次按照3個(gè)增量，第三次按照1個(gè)增量分組第一次循環(huán)的增量為7 第一次是下標(biāo) 0 與 0+7比較 1與1+7比較 …… 7 與 7+7比較 第一次循環(huán)完，這些位置上有了個(gè)大概的順序第二次循環(huán)的增量為3 第二次是下標(biāo) 0與3與6與9與12比較 1與4與7與10與13 2與5與8與11與14 第二次循環(huán)完，這些位置上有了大概的順序第三次循環(huán)的增量為1 就相當(dāng)于簡(jiǎn)單的插入排序

希爾排序的精髓就在于，對(duì)于一個(gè)大概有序的數(shù)組，插入排序的比較和移動(dòng)次數(shù)都比較少

PS：小編作圖能力有限，上圖是當(dāng)來(lái)的

//除main方法外的其他cout輸出都是為了讓讀者更清楚的了解每次循環(huán)后進(jìn)行排序的下標(biāo) #include <iostream> #include <vector>using namespace std;void shellSort(vector<int> &num);int main() {int n; //n為將要輸入的數(shù)組長(zhǎng)度cin >> n; //輸入n cin方法需要上面使用stdvector<int> num; //定義vector 記得上面導(dǎo)入vectorint temp; //temp為輸入vector時(shí)的中間變量for (int i = 0; i < n; i++) {cin >> temp; //輸入num.push_back(temp);}shellSort(num); //調(diào)用自定義的排序方法cout << "\n\n排序后" << "\n";for (int i = 0; i < num.size(); i++) {cout << num[i] << " "; //輸出}return 0; }void shellSort(vector<int> &num) {int len = num.size();for (int d = len / 2; d > 0; d/=2) { //按照增量分組，增量每次/2cout << "\n\n增量為" << d;for (int i = d; i < len; i++) { //類似插入排序，每次都比較i之前的，cout << "\n此次排序的下標(biāo)為:" << i;for (int j = i - d; j >=0; j-=d) {cout << " " << j;//這里i-d其實(shí)也就是從前面開始，// j每次都是j-=d，因?yàn)槲覀兪前凑障嗤隽糠譃橐唤M的// 對(duì)比上圖更容易理解if (num[j] > num[j + d]) { //只要前面的比后面的大，就交換位置int temp = num[j];num[j] = num[j + d];num[j + d] = temp;}}//每次循環(huán)都把數(shù)組的變動(dòng)輸出出來(lái)cout << "\n";for (int j = 0; j < num.size(); j++) {cout << num[j] << " ";}}} }

快速排序

思路：
從未排序的數(shù)組中，一個(gè)一個(gè)的尋找，尋找當(dāng)前值應(yīng)該在排序后數(shù)組的位置，
以此類推，把每個(gè)值的位置都確定了以后，此數(shù)組就變成了排序后的數(shù)組
也是分段進(jìn)行確定某個(gè)值最終排序后的下標(biāo)

先選取第一個(gè)值，用一個(gè)臨時(shí)變量保存這個(gè)值，然后雙指針i表示這段范圍的開頭，j這段范圍的結(jié)尾 j負(fù)責(zé)從后向前找小于臨時(shí)變量的值，找到以后就把j的值放到i那，此時(shí)j位置就空出來(lái)了，我們當(dāng)作把臨時(shí)變量的值放到j(luò)這里i負(fù)責(zé)從前向后找大于臨時(shí)變量的值，找到后就放到j(luò)那里，此時(shí)i位置就空出來(lái)了，我們同樣當(dāng)作把臨時(shí)變量的值放到i這里不斷循環(huán)這兩步的操作，i是從前向后，j是從后向前循環(huán)結(jié)束的條件就是i==j 也就是臨時(shí)變量排序后數(shù)組的位置，按照這種排序方式，結(jié)束后，比臨時(shí)變量小的都在臨時(shí)變量左邊（左邊不一定是排好序的），比臨時(shí)變量大的都在臨時(shí)變量右邊（右邊不一定是排好序的），也就是說(shuō)臨時(shí)變量當(dāng)前的下標(biāo)就是排序后的下標(biāo) 當(dāng)前臨時(shí)變量的位置確定好以后，我們可以分為前半部分和后半部分繼續(xù)這種操作 以此類推，當(dāng)每個(gè)值最終排序后的位置都確定的時(shí)候，此數(shù)組為排序后的數(shù)組

下圖為確定好一個(gè)值的最終位置的排序圖

臨時(shí)變量為50，左指針low，右指針high

右指針找到20比臨時(shí)變量小，交換兩個(gè)值

左指針找到90比臨時(shí)變量大，交換兩個(gè)值

右指針找到40比臨時(shí)變量小，交換兩個(gè)值位置

左指針找到70比臨時(shí)變量小，交換兩個(gè)值的位置

右指針左移與左指針重合，當(dāng)前位置為50排序后的最終位置

我們發(fā)現(xiàn)，左邊的數(shù)都比50小，右邊的數(shù)都比50大，
當(dāng)前數(shù)的位置就是排序后當(dāng)前數(shù)的位置 然后在把左邊的數(shù)組按照這種方法，右邊的數(shù)組按照這種方法
以此類推每個(gè)值的最終下標(biāo)都確定下來(lái)了，數(shù)組為排序后的數(shù)組
PS：圖仍然是某度當(dāng)來(lái)的o(￣▽￣)ブ

#include <iostream> #include <vector>using namespace std;void quickSort(vector<int> &num, int left, int right);int main() {int n; //n為將要輸入的數(shù)組長(zhǎng)度cin >> n; //輸入n cin方法需要上面使用stdvector<int> num; //定義vector 記得上面導(dǎo)入vectorint temp; //temp為輸入vector時(shí)的中間變量for (int i = 0; i < n; i++) {cin >> temp; //輸入num.push_back(temp);}quickSort(num, 0, num.size() - 1); //調(diào)用自定義的排序方法cout << "\n\n排序后" << "\n";for (int i = 0; i < num.size(); i++) {cout << num[i] << " "; //輸出}return 0; }void quickSort(vector<int> &num, int left, int right) {if (left >= right) return; //如果左節(jié)點(diǎn)>=右節(jié)點(diǎn)了，證明排序結(jié)束了，返回即可int temp = num[left]; //保存一下當(dāng)前左節(jié)點(diǎn)的值，此次排序就是確定當(dāng)前左節(jié)點(diǎn)的值int l = left; //保存一下原始的左右邊界int r = right;while (left < right) { //循環(huán)的結(jié)束條件就是左指針 == 右指針，相等時(shí)就為temp排序后的最終位置while (left < right && temp < num[right]) { //右指針找比temp小的值，如果沒(méi)找到就一直找right--;}if (left < right) { //上面循環(huán)結(jié)束了就證明找到了，如果left == right，那么最終位置就確定好了，num[left] = num[right]; //然后把比temp小的放到左面left位置那里，然后left指向下一個(gè)值left++; //可能這里有些疑問(wèn)，上面描述的是交換，這里沒(méi)有交換，實(shí)際上每次都交換，換來(lái)?yè)Q去，每次都重復(fù)換temp這個(gè)數(shù)} //不如直接賦值，然后把這個(gè)重復(fù)數(shù)直接放到最后確定的位置while (left < right && num[left] < temp) { //這里是左指針找比temp大的數(shù)，找到就退出循環(huán)了，left++;}if (left < right) { //與上面相反的道理，把比temp大的數(shù)放到right，right指針左移num[right] = num[left];right--;}}num[left] = temp; //循環(huán)結(jié)束就是確定了temp最終的位置，左指針==右指針//每次循環(huán)都把數(shù)組的變動(dòng)輸出出來(lái)cout << "\n左邊界下標(biāo):" << l << " 右邊界下標(biāo):" << r << " 當(dāng)前循環(huán)確定的下標(biāo)為:" << left << "\n";for (int j = 0; j < num.size(); j++) {cout << num[j] << " ";}quickSort(num, l, left - 1); //temp確定好了位置，把temp左面的數(shù)組和右面的數(shù)組分別進(jìn)行這種方法排序quickSort(num, left + 1, r); //當(dāng)每個(gè)值的下標(biāo)都確定的時(shí)候，該數(shù)組以完成排序 }

二路歸并排序

思路：
二路歸并，就是把一個(gè)數(shù)組，先分開，然后在合并的過(guò)程中逐步排序
二路就是分開的時(shí)候每次分成兩個(gè)，分成兩種路
歸并就是把他分開在合上

二路分割數(shù)組，一直把數(shù)組分割到一路只有一個(gè)數(shù)為止
然后再把他們兩路合一路，兩路合一路，在合路的過(guò)程中把無(wú)序的路合成有序的路，慢慢的合成后的路都為有序的路，大致原理如下圖

分路沒(méi)有什么說(shuō)的，一分為，對(duì)半分即可
合路的時(shí)候，AB兩個(gè)路合成C路，分別兩個(gè)指針i，j，k對(duì)應(yīng)著A，B，C數(shù)組的下標(biāo)
循環(huán)AB兩個(gè)數(shù)組，每次都比較A[i]與B[j] 取兩個(gè)數(shù)組中對(duì)應(yīng)值小的放到C[k]
然后k下標(biāo)右移，i或者j小的下標(biāo)右移，完全循環(huán)后，C==A+B的有序路

#include <iostream> #include <vector>using namespace std;void mergeSort(vector<int> &num, int left, int right);int main() {int n; //n為將要輸入的數(shù)組長(zhǎng)度cin >> n; //輸入n cin方法需要上面使用stdvector<int> num; //定義vector 記得上面導(dǎo)入vectorint temp; //temp為輸入vector時(shí)的中間變量for (int i = 0; i < n; i++) {cin >> temp; //輸入num.push_back(temp);}mergeSort(num, 0, num.size() - 1); //調(diào)用自定義的排序方法cout << "\n\n排序后" << endl;for (int i = 0; i < num.size(); i++) {cout << num[i] << " "; //輸出}return 0; }void mergeSort(vector<int> &num, int left, int right) {if (left == right) return; //如果左節(jié)點(diǎn)和右節(jié)點(diǎn)相等，說(shuō)明就分到底了，一路只剩下一個(gè)元素int m = (left + right) / 2; //左節(jié)點(diǎn)和右節(jié)點(diǎn)的中間節(jié)點(diǎn)，從中間節(jié)點(diǎn)分路，左面一路，右面一路mergeSort(num, left, m); //先分左面->左面進(jìn)入后還會(huì)從上面再來(lái)，接著分，一直分到一路只有一個(gè)元素mergeSort(num, m + 1, right); //再分右面//走到這里說(shuō)明已經(jīng)分完了，接下來(lái)就是合并int temp [right - left + 1]; //定義一個(gè)數(shù)組，用來(lái)存兩路合并后的有序數(shù)組int l = left; //左路起始點(diǎn)下標(biāo)int r = m + 1; //右路起始點(diǎn)下標(biāo)int k = 0; //合路的起始點(diǎn)下標(biāo)while (l <= m && r <= right) { //每次放到時(shí)候比較對(duì)應(yīng)的值，小的值放到前面，l要在左路的范圍內(nèi)，r要在右路的范圍內(nèi)if (num[l] <= num[r]) { //誰(shuí)小把誰(shuí)放到合路temp[k++] = num[l++];} else {temp[k++] = num[r++];}}//下面兩個(gè)while循環(huán)處理的是一路全部放進(jìn)合路了，另一路沒(méi)有完全放進(jìn)，循環(huán)的作用就是把兩路上面沒(méi)放進(jìn)去的全部放進(jìn)去while (l <= m) {temp[k++] = num[l++];}while (r <= right) {temp[k++] = num[r++];}//temp就是我們合路，然后我們把合好的路放回到num原數(shù)組中for (int i = left, k = 0; i <= right; i++, k++) {num[i] = temp[k];}//每次循環(huán)都把數(shù)組的變動(dòng)輸出出來(lái)cout << "此次合并的是下標(biāo)：" << left << "-" << right << "\n";for (int j = 0; j < num.size(); j++) {cout << num[j] << " ";}cout << "\n"; }

Acwing，這個(gè)題就是歸并排序 788. 逆序?qū)Φ臄?shù)量給定一個(gè)長(zhǎng)度為 n 的整數(shù)數(shù)列，請(qǐng)你計(jì)算數(shù)列中的逆序?qū)Φ臄?shù)量。逆序?qū)Φ亩x如下：對(duì)于數(shù)列的第 i 個(gè)和第 j 個(gè)元素，如果滿足 i<j 且 a[i]>a[j]，則其為一個(gè)逆序?qū)?#xff1b;否則不是。輸入格式 第一行包含整數(shù) n，表示數(shù)列的長(zhǎng)度。第二行包含 n 個(gè)整數(shù)，表示整個(gè)數(shù)列。輸出格式 輸出一個(gè)整數(shù)，表示逆序?qū)Φ膫€(gè)數(shù)。數(shù)據(jù)范圍 1≤n≤100000， 數(shù)列中的元素的取值范圍 [1,109]。輸入樣例： 6 2 3 4 5 6 1 輸出樣例： 5#include <iostream> #include <vector>using namespace std;void mergeSort(vector<int> &num, int left, int right);int res = 0; int main() {int n; //n為將要輸入的數(shù)組長(zhǎng)度cin >> n; //輸入n cin方法需要上面使用stdvector<int> num; //定義vector 記得上面導(dǎo)入vectorint temp; //temp為輸入vector時(shí)的中間變量for (int i = 0; i < n; i++) {cin >> temp; //輸入num.push_back(temp);}mergeSort(num, 0, num.size() - 1); //調(diào)用自定義的排序方法cout << res;return 0; }void mergeSort(vector<int> &num, int left, int right) {if (left == right) return; //如果左節(jié)點(diǎn)和右節(jié)點(diǎn)相等，說(shuō)明就分到底了，一路只剩下一個(gè)元素int m = (left + right) / 2; //左節(jié)點(diǎn)和右節(jié)點(diǎn)的中間節(jié)點(diǎn)，從中間節(jié)點(diǎn)分路，左面一路，右面一路mergeSort(num, left, m); //先分左面->左面進(jìn)入后還會(huì)從上面再來(lái)，接著分，一直分到一路只有一個(gè)元素mergeSort(num, m + 1, right); //再分右面//走到這里說(shuō)明已經(jīng)分完了，接下來(lái)就是合并int temp [right - left + 1]; //定義一個(gè)數(shù)組，用來(lái)存兩路合并后的有序數(shù)組int l = left; //左路起始點(diǎn)下標(biāo)int r = m + 1; //右路起始點(diǎn)下標(biāo)int k = 0; //合路的起始點(diǎn)下標(biāo)while (l <= m && r <= right) { //每次放到時(shí)候比較對(duì)應(yīng)的值，小的值放到前面，l要在左路的范圍內(nèi)，r要在右路的范圍內(nèi)if (num[l] <= num[r]) { //誰(shuí)小把誰(shuí)放到合路temp[k++] = num[l++];} else {temp[k++] = num[r++];res += m - l + 1; //當(dāng)前l(fā)大于r證明l到m的數(shù)都大于r//歸并就是一段一段的排好序的數(shù)組合并起來(lái)的}}//下面兩個(gè)while循環(huán)處理的是一路全部放進(jìn)合路了，另一路沒(méi)有完全放進(jìn)，循環(huán)的作用就是把兩路上面沒(méi)放進(jìn)去的全部放進(jìn)去while (l <= m) {temp[k++] = num[l++];}while (r <= right) {temp[k++] = num[r++];}//temp就是我們合路，然后我們把合好的路放回到num原數(shù)組中for (int i = left, k = 0; i <= right; i++, k++) {num[i] = temp[k];}}

基數(shù)排序

說(shuō)基數(shù)排序之前，先大概說(shuō)一下計(jì)數(shù)排序

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

計(jì)數(shù)排序就是把元素的值當(dāng)作下標(biāo)使用，數(shù)量用那個(gè)下標(biāo)對(duì)應(yīng)的值記錄
例如int num[]={5，2，1，4，3，2，1，2，6，4，1，2，5，2}
這樣的數(shù)組我們就用計(jì)數(shù)排序
count的長(zhǎng)度是上面數(shù)組的最大值-最小值+1或者最大值-最小值+1
循環(huán)上面的數(shù)組 count[num[i]]++;
到時(shí)候判斷這個(gè)值存不存在，直接判斷count[值]是否大于0
顯而易見(jiàn)，計(jì)數(shù)排序的缺點(diǎn)就是如果數(shù)組中最大值很大，那么這個(gè)效率會(huì)很低

leetcode 計(jì)數(shù)排序例題 1122. 數(shù)組的相對(duì)排序 給你兩個(gè)數(shù)組，arr1 和 arr2，arr2 中的元素各不相同 arr2 中的每個(gè)元素都出現(xiàn)在 arr1 中 對(duì) arr1 中的元素進(jìn)行排序，使 arr1 中項(xiàng)的相對(duì)順序和 arr2 中的相對(duì)順序相同。未在 arr2 中出現(xiàn)過(guò)的元素需要按照升序放在 arr1 的末尾。示例：輸入：arr1 = [2,3,1,3,2,4,6,7,9,2,19], arr2 = [2,1,4,3,9,6] 輸出：[2,2,2,1,4,3,3,9,6,7,19]提示：1 <= arr1.length, arr2.length <= 1000 0 <= arr1[i], arr2[i] <= 1000 arr2 中的元素 arr2[i] 各不相同 arr2 中的每個(gè)元素 arr2[i] 都出現(xiàn)在 arr1 中class Solution {//arr2的數(shù)在arr1中一定出現(xiàn)//arr1的數(shù)不一定在arr2中有//arr2在arr1中出現(xiàn)過(guò)的數(shù)，按照arr2的相對(duì)順序排列，arr1中剩下的數(shù)按照升序排在后面 public:vector<int> relativeSortArray(vector<int>& arr1, vector<int>& arr2) {int upper = *max_element(arr1.begin(), arr1.end());vector<int> count(upper + 1);//arr1中的數(shù)計(jì)數(shù)放到countfor (int x: arr1) {++count[x];}vector<int> ans;//如果arr1出現(xiàn)的數(shù)，arr2也出現(xiàn)了就輸出//這樣就是按照arr2的相對(duì)順序輸出for (int x: arr2) {for (int i = 0; i < count[x]; ++i) {ans.push_back(x);}//arr2出現(xiàn)的數(shù)字，就添加到ans里面，//添加過(guò)就把這個(gè)數(shù)字清零了，count[x] = 0;}//把剩下的未在arr2中出現(xiàn)的按照升序輸出for (int x = 0; x <= upper; ++x) {for (int i = 0; i < count[x]; ++i) {ans.push_back(x);}}return ans;} };

再回來(lái)說(shuō)基數(shù)排序
基數(shù)排序也是大概這個(gè)意思，不過(guò)不是直接把值當(dāng)作下標(biāo)，而是把值的每一位當(dāng)作下標(biāo)排序
這個(gè)也需要保存一下最大值，因?yàn)橐袛嘧罡哂卸嗌傥弧?br /> 先把個(gè)位放進(jìn)去，排序，再把十位放進(jìn)去排序，然后……

把個(gè)位放進(jìn)去后，就按照個(gè)位排序好了，把數(shù)取出，記得按照順序取出， 然后十位放進(jìn)去排序，把數(shù)按順序取出……
思路大概就是這樣
順序放入順序取出，在進(jìn)行下一位的排序
PS:
如果是Java的話，直接用一個(gè)ArrayList[] temp; 這種數(shù)組就可以

PS：當(dāng)來(lái)的圖片

#include <iostream> #include <vector>using namespace std;void radixSort(vector<int> &num);int main() {int n; //n為將要輸入的數(shù)組長(zhǎng)度cin >> n; //輸入n cin方法需要上面使用stdvector<int> num; //定義vector 記得上面導(dǎo)入vectorint temp; //temp為輸入vector時(shí)的中間變量for (int i = 0; i < n; i++) {cin >> temp; //輸入num.push_back(temp);}radixSort(num); //調(diào)用自定義的排序方法cout << "\n\n排序后" << endl;for (int i = 0; i < num.size(); i++) {cout << num[i] << " "; //輸出}return 0; }void radixSort(vector<int> &num) {int max = -1;for (int i = 0; i < num.size(); i++) {max = max < num[i] ? num[i] : max;}int temp[num.size()];int count[10] = {0};for (int i = 0; i < num.size(); i++) {temp[i] = 0; //初始化temp賦值0}for (int places = 1; places <= max; places *= 10) { //基數(shù)排序就是按照位數(shù)進(jìn)行排序，所以循環(huán)的次數(shù)就是數(shù)字位數(shù)for (int i = 0; i < num.size(); i++) {count[(num[i] / places) % 10]++; // 記錄一下當(dāng)前位上，各個(gè)數(shù)字的個(gè)數(shù)} //count[3]如果是5 就代表的個(gè)位為3的數(shù)是5個(gè)//當(dāng)前位置上各個(gè)數(shù)字的個(gè)數(shù)確定了，我們就可以確定當(dāng)前位某個(gè)數(shù)字的范圍了//count[0] = 3, count[1] = 4, count[2] = 7, count[3] = 2……//當(dāng)前位上為0的數(shù)在此次排序后的位置為數(shù)組1-3，當(dāng)前位為1的數(shù)在此次位置為4-7，當(dāng)前位為2的數(shù)的范圍8-14……//也就是前面的和，加起來(lái)，得出的count[i] 就是當(dāng)前位為i的數(shù)的范圍的右邊界for (int i = 1; i < 10; i++) {count[i] = count[i - 1] + count[i];}//因?yàn)槲覀兩厦鎐ount[i]得出的是當(dāng)前位為i的時(shí)候的右邊界，所以排序后的數(shù)組我們也應(yīng)該從右面放//如果這里我們從左面開始放就會(huì)把放入的順序弄反，我們已知右邊界，然后把數(shù)字從右開始放順序是正的//當(dāng)然我們上一步也可以求每段范圍的左邊界，如果求得是左邊界就可以從左放for (int i = num.size() - 1; i >= 0; i--) {int k = (num[i] / places) % 10; //count[k]就是當(dāng)前位為k的值的右邊界temp[count[k] - 1] = num[i]; //這里的右邊界我們用的是位置，下標(biāo)要記得-1count[k]--; //當(dāng)前位為k的數(shù)放進(jìn)去后，count[k]要-1 因?yàn)橐呀?jīng)放進(jìn)去一個(gè)數(shù)了，右邊界左移一位}//當(dāng)所有的都循環(huán)完以后，count[i]代表的是當(dāng)前位為i的數(shù)字范圍的左邊界for (int i = 0; i < 10; i++) {count[i] = 0;}//把此次排序的數(shù)組放到num中for (int i = 0; i < num.size(); i++) {num[i] = temp[i];}//輸出展示此次排序后的數(shù)組cout << "\n哪一位是1，此次排序就是排的哪一位 " << places << "\n";for (int i = 0; i < num.size(); i++) {cout << num[i] << " ";}}}

簡(jiǎn)單選擇排序

思路：
簡(jiǎn)單選擇排序，顧名思義，簡(jiǎn)單的選擇一個(gè)元素排序
兩層循環(huán)，第一層循環(huán)就是循環(huán)每一位
第二層循環(huán)，定義臨時(shí)變量保存當(dāng)前下標(biāo)，循環(huán)后面每一位，
如果找到比當(dāng)前下標(biāo)對(duì)應(yīng)的值小的，那么就用這個(gè)變量保存這個(gè)值小的下標(biāo)，一直循環(huán)到結(jié)束
第一層循環(huán)結(jié)束后，變量保存的就是整個(gè)數(shù)組最小的值的下標(biāo)，與第一位交換，第一位就是最小的值
如此往復(fù)，第二次循環(huán)，就從第二位開始向后找，記錄除第一位最小的值的下標(biāo)，循環(huán)結(jié)束后與第二位進(jìn)行交換
以此類推，循環(huán)后即可完成排序。

#include <iostream> #include <vector>using namespace std;void selectSort(vector<int> &num);int main() {int n; //n為將要輸入的數(shù)組長(zhǎng)度cin >> n; //輸入n cin方法需要上面使用stdvector<int> num; //定義vector 記得上面導(dǎo)入vectorint temp; //temp為輸入vector時(shí)的中間變量for (int i = 0; i < n; i++) {cin >> temp; //輸入num.push_back(temp);}selectSort(num); //調(diào)用自定義的排序方法cout << "排序后" << "\n";for (int i = 0; i < num.size(); i++) {cout << num[i] << " "; //輸出}return 0; }void selectSort(vector<int> &num) {for (int i = 0; i < num.size(); i++) { //循環(huán)每一位int temp = i; //保存當(dāng)前位的下標(biāo)for (int j = i + 1; j < num.size(); j++) { //循環(huán)后面每一位，找到值比當(dāng)前小的就保存值小的下標(biāo)if (num[j] < num[temp]) {temp = j;}}int n = num[i]; //temp保存的是i后面最小值的下標(biāo)，與下標(biāo)為i的值交換num[i] = num[temp]; //如此往復(fù)，小的值到了前面，次小的到了第二位，……num[temp] = n;//每次循環(huán)都把數(shù)組的變動(dòng)輸出出來(lái)for (int j = 0; j < num.size(); j++) {cout << num[j] << " ";}cout << "\n";} }

運(yùn)行結(jié)果如下：

堆排序

思路：
首先要強(qiáng)調(diào)一下，堆排序并不是要構(gòu)成一個(gè)堆，它本身還是個(gè)數(shù)組，只不過(guò)是我們?cè)谂判虻臅r(shí)候把他看成一個(gè)堆，他實(shí)際上還是一個(gè)數(shù)組
我們這里用到的堆是大根堆和小根堆，他們都是完全二叉樹
完全二叉樹就是他們結(jié)點(diǎn)位置和滿二叉樹的位置是一樣的

紅色角標(biāo)為真實(shí)數(shù)組的下標(biāo)

PS：圖片來(lái)源
這是大根堆和小根堆

完全二叉樹和滿二叉樹基本相同
每一層的數(shù)量都是上一層的二倍
某一層最左邊結(jié)點(diǎn)下標(biāo)*2就是最右邊結(jié)點(diǎn)下標(biāo)

完全二叉樹中子結(jié)點(diǎn)和父結(jié)點(diǎn)之間還有一些顯著的關(guān)系
一個(gè)數(shù)的下標(biāo)為x
他的父節(jié)點(diǎn)下標(biāo)為（x - 1）/ 2 這里的除2是計(jì)算機(jī)除2，不保存余數(shù)，整除不成為小數(shù)
他的左子結(jié)點(diǎn)為 2 * x + 1
他的右子結(jié)點(diǎn)為 2 * x + 2

如果還不明白，可以自己帶個(gè)結(jié)點(diǎn)試一下（看堆分析容易理解）
（左子結(jié)點(diǎn)-1）/2就是父節(jié)點(diǎn) （右子結(jié)點(diǎn) - 1）/2也是父節(jié)點(diǎn)，它除2的時(shí)候會(huì)把余數(shù)直接省去

大根堆就是 父節(jié)點(diǎn) > 左子結(jié)點(diǎn) 并且 父節(jié)點(diǎn) > 右子結(jié)點(diǎn)
小根堆就是 父節(jié)點(diǎn) < 左子結(jié)點(diǎn) 并且 父節(jié)點(diǎn) < 右子結(jié)點(diǎn)

構(gòu)建大根堆只是思想構(gòu)建，不是實(shí)際構(gòu)建，實(shí)際還是數(shù)組
先把數(shù)組構(gòu)建成大根堆，大根堆不一定是有序的，但一定是符合大根堆的規(guī)律，父結(jié)點(diǎn)一定比子結(jié)點(diǎn)大，全部構(gòu)建好（構(gòu)建大根堆，一定要從下向上構(gòu)建，如果無(wú)序直接從上向下構(gòu)建，有的會(huì)不符合大根堆定義）

默認(rèn)葉子結(jié)點(diǎn)為排好序的堆（葉子結(jié)點(diǎn)沒(méi)有子結(jié)點(diǎn)，只有一層，符合大跟堆得特征） 先添加非葉子結(jié)點(diǎn)，逐步向上添加 如果從上到下結(jié)點(diǎn)添加，葉子結(jié)點(diǎn)為有序堆，上到下添加會(huì)把有序堆打散，無(wú)法完成堆排序 完全二叉樹的特點(diǎn)，n個(gè)結(jié)點(diǎn)，最后一個(gè)非葉子結(jié)點(diǎn)二叉樹為（n/2）下標(biāo)為（n/2-1），逐步向上添加

構(gòu)建好大根堆后，轉(zhuǎn)換成小根堆

轉(zhuǎn)換小根堆的步驟，先把大根堆最大的（也就是堆頂）與最后面的結(jié)點(diǎn)換位置，這樣能保證最大的在最后面，也就是說(shuō)，數(shù)組第一位與最后一位交換
交換完，小的就到了最上面，把剛交換完最大的固定不動(dòng)，其他的重新構(gòu)建大根堆
此時(shí)最大的在最后面，其他的仍然是大根堆

第二次的時(shí)候，把當(dāng)前大根堆最大的值（當(dāng)前堆頂）與倒數(shù)第二位交換（倒數(shù)第一位是剛才的堆頂，最大的，已經(jīng)固定了，保持不變），最小的又到了堆頂，繼續(xù)重建大根堆
如此往復(fù)，大根堆就變成了小根堆，此時(shí)的小根堆就是有序的

#include <iostream> #include <vector>using namespace std;void heapSort(vector<int> &num);void heapBuild(vector<int> &num, int fatherIndex, int len);int main() {int n; //n為將要輸入的數(shù)組長(zhǎng)度cin >> n; //輸入n cin方法需要上面使用stdvector<int> num; //定義vector 記得上面導(dǎo)入vectorint temp; //temp為輸入vector時(shí)的中間變量for (int i = 0; i < n; i++) {cin >> temp; //輸入num.push_back(temp);}heapSort(num); //調(diào)用自定義的排序方法cout << "\n\n排序后" << endl;for (int i = 0; i < num.size(); i++) {cout << num[i] << " "; //輸出}return 0; }void heapSort(vector<int> &num) {//構(gòu)建大根堆for (int i = num.size() / 2 - 1; i >= 0; i--) { // 倒數(shù)第二排開始, 創(chuàng)建大頂堆，必須從下往上比較heapBuild(num, i, num.size()); // 否則有的不符合大頂堆定義}cout << "構(gòu)建完大根堆后的數(shù)組\n";for (int i = 0; i < num.size(); i++) {cout << num[i] << " ";}int len = num.size();//也算一種選擇排序，因?yàn)槊看伟汛蟾诺阶詈缶蜕倥判蛞粋€(gè)while (len > 1) {//每次都把大根與最后面的值交換，int temp = num[0];num[0] = num[len - 1];num[len - 1] = temp;len--; //最后一個(gè)元素也就是剛才的大根已經(jīng)確定好了，可以少排序一個(gè)元素heapBuild(num, 0, len); //除去確定好的大根，把剩下的元素重新構(gòu)建cout << "\n下標(biāo)："<< len << " 值：" << num[len] <<" 確定好位置了\n";for (int i = 0; i < num.size(); i++) {cout << num[i] << " ";}} }void heapBuild(vector<int> &num, int fatherIndex, int len) {//堆（完全二叉樹）左子結(jié)點(diǎn)和右子結(jié)點(diǎn)與父結(jié)點(diǎn)的關(guān)系int left = fatherIndex * 2 + 1;int right = fatherIndex * 2 + 2;while (left < len) {int largestIndex; //largestIndex保存的是當(dāng)前子結(jié)點(diǎn)與父結(jié)點(diǎn)中最大的索引if (num[left] < num[right] && right < len) {largestIndex = right;} else {largestIndex = left;}if (num[largestIndex] < num[fatherIndex]) { //如果父節(jié)點(diǎn)大于子結(jié)點(diǎn)，當(dāng)前符合大根堆,退出即可largestIndex = fatherIndex;break;}//不符合大根堆就交換int temp = num[largestIndex];num[largestIndex] = num[fatherIndex];num[fatherIndex] = temp;//接著去下面構(gòu)建大根堆fatherIndex = largestIndex;left = fatherIndex * 2 + 1;right = fatherIndex * 2 + 2;} }

總結(jié)

以上是生活随笔為你收集整理的22计算机408考研—数据结构—排序（详解加例题）的全部?jī)?nèi)容，希望文章能夠幫你解決所遇到的問(wèn)題。

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