十大排序算法（Top 10 Sorting Algorithms）

0. 排序算法概述

十种常见排序算法可以分为两大类：

比较类排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此也称为非线性时间比较类排序。
非比较类排序：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此也称为线性时间非比较类排序。

1. 选择排序（Selection Sort）

基本思想：

首先找到数组中最小的那个元素，将它和数组的第一个元素交换位置。然后在剩下的元素中找到最小的元素，将它与数组的第二个元素交换位置。如此往复，直到将整个数组排序。

代码实现：

// 两数交换
void mySwap(int &a, int &b) {int tmp = a;a = b;b = tmp;
}// 选择排序
void SelectionSort(vector<int> &num) {int len = num.size();for (int i = 0; i < len - 1; ++i) {int minPos = i;for (int j = i + 1; j < len; ++j) {if (num[j] < num[minPos])minPos = j;}mySwap(num[i], num[minPos]);}
}

算法分析：

时间复杂度：O(n2)O(n^2)O(n2)
空间复杂度：O(1)O(1)O(1)
稳定性：不稳定排序

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

基本思想：

把第一个元素作为有序部分，从第二个元素开始将剩余元素逐个插入有序部分的合适位置，最终得到排序的序列。

代码实现：

// 直接插入排序
void InsertionSort(vector<int> &num) {int len = num.size();for (int i = 1; i < len; ++i) {int tmp = num[i];int j = i - 1;while (j >= 0 && num[j] > tmp) {num[j + 1] = num[j];--j;}num[j + 1] = tmp;}
}

算法分析：

时间复杂度：O(n2)O(n^2)O(n2)
空间复杂度：O(1)O(1)O(1)
稳定性：稳定排序

3. 冒泡排序（Bubble Sort）

基本思想：

把第一个元素与第二个元素比较，如果第一个比第二个大，则交换他们的位置。接着继续比较第二个与第三个元素，如果第二个比第三个大，则交换他们的位置……对每一对相邻元素执行同样操作，一趟比较完成后，排在最右的元素便是最大的数。除去最右的元素，对剩余的元素做同样的工作，最终得到排序序列。

代码实现：

// 冒泡排序
void BubbleSort(vector<int> &num) {int len = num.size();for (int i = 0; i < len; ++i) {for (int j = 0; j < len - i - 1; ++j) {if (num[j + 1] < num[j])mySwap(num[j + 1], num[j]);}}
}

算法分析：

时间复杂度：O(n2)O(n^2)O(n2)
空间复杂度：O(1)O(1)O(1)
稳定性：稳定排序

算法优化：

假如从开始的第一对到结尾的最后一对，相邻的元素之间都没有发生交换的操作，这意味着右边的元素总是大于等于左边的元素，此时的数组已经是有序的了，无需再对剩余的元素重复比较下去了。

// 冒泡排序优化
void BubbleSortPlus(vector<int> &num) {int len = num.size();for (int i = 0; i < len; ++i) {bool flag = true;for (int j = 0; j < len - i - 1; ++j) {if (num[j + 1] < num[j]) {mySwap(num[j + 1], num[j]);flag = false;}}if (flag)break;}
}

4. 希尔排序（Shell Sort）

基本思想：

希尔排序可以说是插入排序的一种变种。无论是插入排序还是冒泡排序，如果数组的最大值刚好是在第一位，要将它挪到正确的位置就需要 n - 1 次移动。也就是说，原数组的一个元素如果距离它正确的位置很远的话，则需要与相邻元素交换很多次才能到达正确的位置，这样是相对比较花时间了。

希尔排序就是为了加快速度简单地改进了插入排序，交换不相邻的元素以对数组的局部进行排序。先让数组中任意间隔为 h 的元素有序，刚开始 h 的大小可以是 h = n / 2,接着让 h = n / 4，让 h 一直缩小，当 h = 1 时，也就是此时数组中任意间隔为1的元素有序，此时的数组就是有序的了。

代码实现：

// 希尔排序
void ShellSort(vector<int> &num) {int len = num.size();// 逐渐缩小间隔，最终为1for (int step = len / 2; step > 0; step /= 2) {   for (int i = step; i < len; ++i) {int tmp = num[i];int j = i - step;while (j >= 0 && tmp < num[j]) {num[j + step] = num[j];j -= step;}num[j + step] = tmp;}}
}

算法分析：

时间复杂度：O(n2)O(n^2)O(n2)
空间复杂度：O(1)O(1)O(1)
稳定性：不稳定排序

5. 归并排序（Merge Sort）

基本思想：

归并排序是建立在归并操作上的一种有效的排序算法。该算法是分治法（Divide and Conquer）的典型应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。

根据具体的实现，归并排序包括"从上往下"和"从下往上"2种方式。

从下往上（循环）：将待排序的数列分成若干个长度为1的子数列，然后将这些数列两两合并；得到若干个长度为2的有序数列，再将这些数列两两合并；得到若干个长度为4的有序数列，再将它们两两合并；直到合并成一个数列为止。这样就得到了最终的排序结果。
从上往下（递归）：它基本包括3步：
- 分解：将当前区间一分为二，即求分裂点 mid = (low + high) / 2；
- 求解：递归地对两个子区间 [low…mid] 和 [mid+1…high] 进行归并排序。递归的终结条件是子区间长度为1；
- 合并：将已排序的两个子区间 [low…mid] 和 [mid+1…high] 归并为一个有序的区间 [low…high]。

5.1 非递归（循环）式归并

代码实现：

// 合并两个有序数组
void Merge(vector<int> &num, int left, int mid, int right) {vector<int> leftSubArray(num.begin() + left, num.begin() + mid + 1);vector<int> rightSubArray(num.begin() + mid + 1, num.begin() + right + 1);int idxLeft = 0, idxRight = 0;// 在数组最后插入int类型能表示的最大值leftSubArray.insert(leftSubArray.end(), numeric_limits<int>::max());rightSubArray.insert(rightSubArray.end(), numeric_limits<int>::max());// 已有元素不可能大于int能表示的最大值，因此能覆盖两个数组中的所有元素for (int i = left; i <= right; i++) {if (leftSubArray[idxLeft] < rightSubArray[idxRight]) {num[i] = leftSubArray[idxLeft];idxLeft++;} else {num[i] = rightSubArray[idxRight];idxRight++;}}
}// 归并排序——非递归
void MergeSortLoop(vector<int> &num) {int len = num.size();// 子数组的大小分别为1，2，4，8...for (int i = 1; i < len; i += i) {// 进行数组划分int left = 0;int mid = left + i - 1;int right = mid + i;// 将数组大小为 i 的数组两两合并while (right < len) {Merge(num, left, mid, right);left = right + 1;mid = left + i - 1;right = mid + i;}// 还有一些被遗漏的数组没合并，因为不可能每个子数组的大小都刚好为 iif (left < len && mid < len) {Merge(num, left, mid, len - 1);}}
}

5.2 递归式归并

代码实现：

// 归并排序——递归
void MergeSortRecursion(vector<int> &num, int left, int right) {if (left >= right)return;int mid = (right - left) / 2 + left;MergeSortRecursion(num, left, mid);MergeSortRecursion(num, mid + 1, right);Merge(num, left, mid, right);
}

算法分析：

时间复杂度：O(n∗logn)O(n*logn)O(n∗logn)
空间复杂度：O(n)O(n)O(n)
稳定性：稳定排序

6. 快速排序（Quick Sort）

基本思想：

从数组中选择一个元素，称为中轴元素。把数组中所有小于中轴元素的元素放在其左边，所有大于或等于中轴元素的元素放在其右边，显然，此时中轴元素所处的位置的是有序的。也就是说，我们无需再移动中轴元素的位置。

以中轴元素为界把大的数组切割成两个小的数组（分割操作，partition），且两个数组都不包含中轴元素。对中轴元素左右两边的数组进行递归操作，直到数组的大小为1。此时每个元素都处于有序的位置。

代码实现：

// 分割操作
int Partition(vector<int> &num, int left, int right) {int pivot = num[left];int i = left + 1, j = right;while (true) {// 向右找到第一个小于等于 pivot 的元素位置while (i <= j && num[i] <= pivot) ++i;// 向左找到第一个大于等于 pivot 的元素位置while(i <= j && num[j] >= pivot ) --j;if(i >= j)break;// 交换两个元素的位置，使得左边的元素不大于pivot,右边的不小于pivotmySwap(num[i], num[j]);}// 使中轴元素处于有序的位置num[left] = num[j];  num[j] = pivot;return j;
}// 另一种分割操作，参考《剑指Offer2》
int Partition2(vector<int> &num, int left, int right) {// 快排时间复杂度与中轴元素的选择有关int index = RandomInRange(left, right);// 随机选择中轴元素mySwap(num[index], num[end]);int small = left - 1;for (int i = left; i < right; ++i) {if (num[i] < num[right]) {++small;if (small != i)mySwap(num[i], num[small]);}}++small;mySwap(num[small], num[right]);return small;
}// 快速排序
void QuickSort(vector<int> &num, int left, int right) {if (left < right) {// 获取中轴元素所处的位置并进行分割int mid = Partition(num, left, right);// 递归处理QuickSort(num, left, mid - 1);QuickSort(num, mid + 1, right);}
}

算法分析：

时间复杂度：O(n∗logn)O(n*logn)O(n∗logn)
空间复杂度：O(logn)O(logn)O(logn)
稳定性：不稳定排序

7. 堆排序（Heap Sort）

基本思想：

堆的特点就是堆顶的元素是一个最值，大顶堆的堆顶是最大值，小顶堆则是最小值。

堆排序就是把堆顶的元素与最后一个元素交换，交换之后破坏了堆的特性，我们再把堆中剩余的元素再次构成一个大顶堆，然后再把堆顶元素与最后第二个元素交换….如此往复下去，等到剩余的元素只有一个的时候，此时的数组就是有序的了。

代码实现：

// 下沉操作
void downAdjust(vector<int> &num, int parent, int n) {  // 临时保存要下沉的元素  int temp = num[parent];      // 定位左孩子节点的位置int child = 2 * parent + 1;    // 开始下沉while (child <= n) {// 如果右孩子节点比左孩子大，则定位到右孩子if (child + 1 <= n && num[child] < num[child + 1])++child;// 如果孩子节点小于或等于父节点，则下沉结束if (num[child] <= temp) break;// 父节点进行下沉num[parent] = num[child];parent = child;child = 2 * parent + 1;}num[parent] = temp;
}// 堆排序
void HeapSort(vector<int> &num) {int len = num.size();// 构建大顶堆for (int i = (len - 2) / 2; i >= 0; --i) {downAdjust(num, i, len - 1);}// 进行堆排序for (int i = len - 1; i >= 1; --i) {// 把堆顶元素与最后一个元素交换mySwap(num[0], num[i]);// 把打乱的堆进行调整，恢复堆的特性downAdjust(num, 0, i - 1);}
}

算法分析：

时间复杂度：O(n∗logn)O(n*logn)O(n∗logn)
空间复杂度：O(1)O(1)O(1)
稳定性：不稳定排序

8. 计数排序（Counting Sort）

基本思想：

计数排序适合于最大值和最小值的差值不是很大的情况。

把数组元素作为数组的下标，然后用一个临时数组统计该元素出现的次数，例如 temp[i] = m, 表示元素 i 一共出现了 m 次。最后再把临时数组统计的数据从小到大汇总起来，此时汇总起来是数据是有序的。

代码实现：

// 计数排序
void CountingSort(vector<int> &num) { int len = num.size();// 得到数列的最大和最小值int max = num[0], min = num[0];  for (int i = 1; i < len; ++i) {        if(num[i] > max)           max = num[i];        if (num[i] < min)min = num[i];}// 根据数列最大值确定统计数组的长度vector<int> countArray(max - min + 1, 0);// 遍历数列，填充统计数组for (int i = 0; i < len; ++i) {countArray[num[i] - min]++;}// 遍历统计数组，输出结果   int index = 0;  for (int i = 0; i < countArray.size(); ++i) {for (int j = 0; j < countArray[i]; ++j) {num[index++] = i + min;}}
}

算法分析：

时间复杂度：O(n+k)O(n+k)O(n+k)，其中k为临时数组大小
空间复杂度：O(k)O(k)O(k)
稳定性：稳定排序

9. 桶排序（Bucket Sort）

基本思想：

桶排序就是把最大值和最小值之间的数进行瓜分，例如分成 10 个区间，10个区间对应10个桶，我们把各元素放到对应区间的桶中去，再对每个桶中的数进行排序，可以采用归并排序、快速排序等方法。之后每个桶里面的数据就是有序的了，按顺序遍历各桶即可得到排序序列。桶排序也可用于浮点数排序。

代码实现：

// 桶排序
// 有负数的话需要进行预处理，本函数包含预处理部分
void BucketSort(vector<int> &num) {   int len = num.size();// 得到数列的最大最小值int max = num[0], min = num[0];  for(int i = 1; i < len; ++i) {        if(num[i] > max)           max = num[i];        if (num[i] < min)min = num[i];}// 计算桶的数量并初始化int bucketNum = (max - min) / len + 1;vector<int> vec;vector<vector<int>> bucket;for (int i = 0; i < bucketNum; ++i)bucket.push_back(vec);// 将每个元素放入桶for (int i = 0; i < len; ++i) {// 减去最小值，处理后均为非负数int pos = (num[i] - min) / len;bucket[pos].push_back(num[i]);}// 对每个桶进行排序，此处可选择不同排序方法for (int i = 0; i < bucket.size(); ++i) sort(bucket[i].begin(), bucket[i].end());// 将桶中的元素赋值到原序列int index = 0;for (int i = 0; i < bucketNum; ++i)for(int j = 0; j < bucket[i].size(); ++j)num[index++] = bucket[i][j];
}

算法分析：

时间复杂度：O(n+k)O(n+k)O(n+k)
空间复杂度：O(k)O(k)O(k)
稳定性：稳定排序

10. 基数排序（Radix Sort）

基本思想：

先以个位数的大小来对数据进行排序，接着以十位数的大小来多数进行排序，接着以百位数的大小……

排到最后，就是一组有序的元素了。在以某位数进行排序的时候，是用“桶”来排序的。

由于某位数（个位/十位….，不是一整个数）的大小范围为0~9，所以我们需要10个桶，然后把具有相同数值的数放进同一个桶里，之后再把桶里的数按照0号桶到9号桶的顺序取出来。一趟下来按照某位数的排序就完成了。

代码实现：

// 基数排序
// 有负数的话需要进行预处理，本函数不包含预处理部分
void RadixSort(vector<int> &num) {int len = num.size();// 得到数列的最大值int max = num[0];  for (int i = 1; i < len; ++i) {        if(num[i] > max)           max = num[i];}// 计算最大值是几位数int times = 1;while (max / 10 > 0) {++times;max /= 10;}// 创建10个桶vector<int> vec;vector<vector<int>> bucket;for (int i = 0; i < 10; ++i) {bucket.push_back(vec);}// 进行每一趟的排序，从个位数开始排for (int i = 1; i <= times; i++) {for (int j = 0; j < len; j++) {// 获取每个数最后第 i 位对应桶的位置int radio = (num[j] / (int)pow(10,i-1)) % 10;// 放进对应的桶里bucket[radio].push_back(num[j]);}// 合并放回原数组int k = 0;for (int j = 0; j < 10; j++) {for (int& t : bucket[j]) {num[k++] = t;}//合并之后清空桶bucket[j].clear();}  }
}

算法分析：

时间复杂度：O(k∗n)O(k*n)O(k∗n)
空间复杂度：O(k+n)O(k+n)O(k+n)
稳定性：稳定排序

11. 总结

参考资料

10 Best Sorting Algorithms You Must Know About
必学十大经典排序算法
归并排序（Merge Sort）
二叉堆是什么鬼？
为什么说O(n)复杂度的基数排序没有快速排序快？