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 ( n 2 ) 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 ( n 2 ) 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 ( n 2 ) 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();
// 逐渐缩小间隔，最终为1
for (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 ( n 2 ) 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;
}
// 还有一些被遗漏的数组没合并，因为不可能每个子数组的大小都刚好为 i
if (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 ∗ l o g n ) 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,右边的不小于pivot
mySwap(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 ∗ l o g n ) O(n*logn) O(n∗logn)
-
空间复杂度： O ( l o g n ) 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 ∗ l o g n ) 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. 总结
扫一扫
3019
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
