目录
一、八大排序剖析链接
以下是各大排序的剖析，点击文字会跳转到对应的文章。
插入排序、希尔排序、堆排序、快速排序
归并排序、选择排序、冒泡排序、计数排序
二、排序的稳定性
在未排序的数据中，有多个相同数据，若经过排序后，相对顺序保持不变。
未排序，r[a] = r[b]，r[a]在r[b]位置前面，排序后，r[a]仍在r[b]前面，说明该排序算法是稳定的，相对顺序改变就不稳定。
2.1 稳定性作用
比如：考试提交成绩的时候，如果两个学生的成绩都是满分，就会按照提交时间来排名，特别是在评奖的时候，保持公平性。
排序稳定的作用就体现出来了，可以保证先提交的一定在前面，后提交的在后面。反之不稳定就可能出现后提交在前。
2.2 如何判断排序算法是否稳定
举一些针对性的例子，特别注意交换过程和比较条件、该排序算法的特性。
插入排序：稳定，因为只有新数据比有序数据小才会移动，相等的情况并不会移动。
希尔排序：不稳定，由于数据会进行分组，在每组进行排序，导致相同的数据会分到不同的组进行预排序，相对顺序就不能保证
- 如：
3，3，1，7，2，9，gap为2，第一个3在该组为最大，第二个3在该组为最小，分组排序的时候就会把第一个3，放到第二3的后面。
堆排序：不稳定，数组中有和堆顶一样的数，堆顶和最后一个交换的时候，相对顺序就会被破坏，因为在顶上的数据会先被交换下来。
快速排序：不稳定，如果选的key，在数据中有一样，就会造成不稳定，因为key会排到正确的位置过程中无法控制相同的值，相同的值在左右两边都可以，key最后不知道放在哪里了。
归并排序：稳定，每次合并的时候都是一个个的合并，两个数据相同，可以让第一个序列先归并。合并顺序是可以调整的。
选择排序：不稳定，在选最小（大）值的时候，被交换的值有相等的值，就会不稳定。
冒泡排序：稳定，当前数据比下一个数据小（大），才交换，相等不会交换。
总结
三、八大排序实现及源代码
3.1 插入排序
实现思路：
- 假设第一个数据（下标0）有序，后面的
n-1个数据都需要插入到有序数组里 - 保存有序数据后面一个数据（tmp）
- 移动数据，需要把新数据插入有序数据中的合适位置
（tmp < end） - 移动数据停止条件有两个：
- 最坏情况：tmp比全部有序的数据要小，有序数据从头到尾都需要移动，end移动到-1，说明移动完成。
- 当tmp > end下标的数据，说明已经有序了。
- 插入数据到end+1的下标位置，因为end下标的数据是小于tmp。
代码：
// 插入排序（升序）
void InsertSort(int* a, int n)
{
// i迭代n - 1结束，到n结束会越界，因为需要访问未排序的数据（i+1 == n+1），就会越界
for (int i = 0; i < n - 1; i++)
{
int end = i; // 有序的个数
int tmp = a[end + 1]; // 需要插入的新数据（未排序的数据）
// 新的数据想要插入都有序数据中，需要移动数据，插入到合适的位置
// 以升序为例，最坏情况：新数据比全部有序的数据要小，有序数据都需要移动
while (end >= 0)
{
// 新数据小于有序数据就要移动数据
if (tmp < a[end])
{
a[end + 1] = a[end];
end--;
}
else
{
// 已经有序
break;
}
}
// 插入数据到end+1的下标位置，end < tmp
a[end + 1] = tmp;
}
}
3.2 希尔排序
实现思路：
先选定一个整数（gap），把待排所有数据分成gap个组，所有距离为差相同的数据分在同一组内，并对每一组内的记录进行排序。然后缩小gap，重复上述分组和排序的工作。当到达gap=1时，所有数据在统一组内排好序。
- 预排序 gap > 1，目的是让数据接近有序
- 直接排序 gap = 1，目的是数据有序
代码：
// 希尔排序（升序）
void ShellSort(int* a, int n)
{
int gap = n;
while (gap > 1)
{
// 缩小gap，最后加1，是确保最后gap=1，为直接插入排序
gap = gap / 3 + 1;
// 一次排多组差距为gap的数据
for (int i = 0; i < n - gap; i++)
{
int end = i;
int tmp = a[end + gap];
while (end >= 0)
{
if (a[end] > tmp)
{
a[end + gap] = a[end];
}
else
{
break;
}
}
a[end + gap] = tmp;
}
}
}
3.3 堆排序
- 建堆，排升序：建大堆，排降序：建小堆
- 通过向下调整，从倒数第一个非叶子节点开始调整
- 堆结构建立完，就排序
- 堆顶的数据和最后一个数据交换，排好的数据排除掉（缩小区间，end–），在重新向下调整把次大的数据放到堆顶，直到堆顶结束（end>0）
代码：
// 交换
void Swap(int* pa, int* pb)
{
int tmp = *pa;
*pa = *pb;
*pb = tmp;
}
// 向下调整
// 大堆
void AdjustDown(int* a, int n, int parent)
{
int child = parent * 2 + 1;
while (child < n)
{
// 找左右孩子最大的
// 防止越界：右孩子可能不存在
if (child + 1 < n && a[child] < a[child + 1])
{
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)
{
// 建大堆，从最后非叶子结点开始到第一个结点
for (int i = (n - 1 - 1) / 2; i >= 0; i--)
{
AdjustDown(a, n, i);
}
// 排序，选出最大的交换到最后，在缩小区间（排除已排好的数据）
int end = n - 1;
while (end > 0)
{
Swap(&a[0], &a[end]); // 交换
AdjustDown(a, end, 0); // 找出次大的，放到堆顶
end--; // 已经排好的数据，给排除
}
}
3.4 快速排序
3.4.1 Hoare版（左右指针法）
- 记录key位置，一般最左边或最右边以此作为分区条件，左右两个指针从两端开始往中间走
- right先走，找到比key小的值停下，left后走，找到比key大的值停下。
- left停止后，说明left的值比key大和right的值比key小，两个数据交换，大的在右边，小的就在左边
- left和right相遇时，需要将key和相遇位置的交换，目的达成，key比左边的值要大，比右边的值要小
- 重复以上操作，直到最后左右区间不存在或者只有1个数，排序就完成了
代码：
// hoare（左右指针法)
void QuickSort(int* a, int begin, int end)
{
// 结束条件：区间不存在或只有一个数，该情况是有序的
if (begin >= end)
return;
int left = begin, right = end;
int keyi = left;
// 相遇就结束
while (left < right)
{
// 右区间找比key小的数
while (left < right && a[right] >= a[keyi])
{
right--;
}
// 左区间找比key大的数
while (left < right && a[left] <= a[keyi])
{
left++;
}
// 交换
Swap(&a[left], &a[right]);
}
// 此时begin和end在同一位置，需要将其中key和其中一个交换
Swap(&a[left], &a[keyi]);
keyi = left; // 更新keyi的位置
// [begin, keyi-1] keyi [keyi+1, end]
QuickSort(a, begin, keyi - 1);
QuickSort(a, keyi + 1, end);
}
3.4.2 挖坑法
- 记录key，key一般都是最左边，目的就是为了把key排到正确的位置，同时将key设为坑位
- 开始坑在左边，右边开始找值补坑，right找到比key小的值，放入坑位，right形成新的坑
- 现在坑在右边，左边开始找值补坑，left找到比key大的值，放入坑位，left形成新的坑
- 直到left和right相遇就结束，最后把key放到坑位，key就排到正确的位置
- 以排好的key（下标为pivot）开始左右分区，[begin, pivot - 1] pivot [pivot + 1, end]，进行分治递归
代码：
void QuickSort_pivot(int* a, int begin, int end)
{
if (begin >= end)
return;
int left = begin, right = end;
int key = a[left];
int pivot = left;
while (left < right)
{
// 找小于key的数
while (left < right && a[right] >= key)
{
right--;
}
// 找到小的数放到左边的坑里，自己形成新的坑位
a[pivot] = a[right];
pivot = right;
// 找大于key的数
while (left < right && a[left] <= key)
{
left++;
}
// 找到大的数放到右边的坑里，自己形成新的坑位
a[pivot] = a[left];
pivot = left;
}
// 最后pivot会指向相遇点，相遇点就是key排好的位置
a[pivot] = key;
// [begin, pivot-1] pivot [pivot+1, end]
QuickSort_pivot(a, begin, pivot - 1);
QuickSort_pivot(a, pivot + 1, end);
}
3.4.3 前后指针法
实现思路：
- 记录key，key一般都是最左边，目的就是为了把key排到正确的位置。
- prev记录begin的位置，cur记录begin+1的位置，cur一直递增的 ，如果cur处的值小于key的值，prev++，然后prev处的值和cur处的值交换（因为prev++后可能会相遇cur，这是原地交换没有意义，所以
prev++ !=cur才交换），直到cur越界就停止 - cur越界后，说明prev的位置就是key排好的位置，所以key和cur处的值交换后，key就排到正确的位置，开始keyi在最左边，需要更新keyi的位置
- 以排好的key开始左右分区，[begin, keyi - 1] keyi [keyi + 1, end]，进行分治递归
需要注意排序的思想两指针间隔，间隔的数都是大于key，当cur遇到小的数，prev++就会在间隔的地方（大于key的数位置），然后交换，就是大的数往后抛，小的数往前抛。
代码：
void QuickSort_pointer(int* a, int begin, int end)
{
if (begin >= end)
return;
int keyi = begin;
int prev = begin, cur = begin + 1;
while (cur <= end)
{
// cur一直递增，碰到小于key的值并且prev++不等于自己，就交换
// prev++ == cur，会原地交换
if (a[cur] < a[keyi] && ++prev != cur)
{
Swap(&a[prev], &a[cur]);
}
cur++;
}
// key交换到排好的位置，同时更新keyi的位置，原先在最左边
Swap(&a[keyi], &a[prev]);
keyi = prev;
// [begin, keyi-1] keyi [keyi+1, end]，进行分治
QuickSort_pointer(a, begin, keyi - 1);
QuickSort_pointer(a, keyi + 1, end);
}
3.4.4 三数取中优化
该优化是针对快排的最坏情况（有序情况），确保在每次在分区里选key的时候，能保证在分区内不会取最或最大的数。
三数取中：最左边和最右边以及中间的数，取这三个数中，值的大小是中间的（不是三个数里最大或最小），比如在有序的情况下中间的值真好能二分区间。
代码如下：
// 三数取中
int GetMidIndex(int* a, int left, int right)
{
int mid = (left + right) / 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[right] < a[left])
return right;
else
return left;
}
}
3.4.5 小区间优化
众所周知，与递归相关的算法，递归的过程类似与二叉树结构，高度是h，一共有 2 h − 1 2^h-1 2h−1个节点，调用就有 2 h − 1 2^h-1 2h−1次，递归到最后几层数据已经接近有序并且调用次数占了大部分（最后一层节点有 2 h − 1 2^{h-1} 2h−1个，每一节点都需要调用，这将近占用一半的调用次数）。所以小区间优化的目的是减少递归调用的次数。
挖坑法加上三数取中和小区间优化代码如下：
void QuickSort_pivot(int* a, int begin, int end)
{
if (begin >= end)
return;
// begin和end是闭区间，如[0,9]，一共10个数，所以+1，10个数以下就小区间优化
if (end - begin + 1 > 10)
{
// 三数取中优化
int midIndex = GetMidIndex(a, begin, end);
Swap(&a[begin], &a[midIndex]);
int left = begin, right = end;
int key = a[left];
int pivot = left;
// 挖坑法
while (left < right)
{
while (left < right && a[right] >= key)
{
right--;
}
a[pivot] = a[right];
pivot = right;
while (left < right && a[left] <= key)
{
left++;
}
a[pivot] = a[left];
pivot = left;
}
a[pivot] = key;
else
{
// 小区间优化
InsertSort(a + begin, end - begin + 1);
}
}
3.4.6 快排非递归版
思路：
- 先入右下标，在左下标，因为可以先取到左下标
- 取左右下标组成一个区间，单趟排好一个值（key），在利用key分成左区间[left，key-1]，右区间[key+1，right]。
- 检查左右区间数据个数，如果区间个数有二个以上，就需要在入栈排序
- 重复2,3步，直到栈为空，数据就都排好了，由于栈的特性，永远左区间先取出，所以先排好，右区间在排好，在过程上就和递归调用一样。
代码如下：
// 快排单趟前后指针法
int SingleQuickSort(int* a, int begin, int end)
{
if (begin >= end)
return;
int keyi = begin;
int prev = begin, cur = begin + 1;
while (cur <= end)
{
if (a[cur] < a[keyi] && ++prev != cur)
{
Swap(&a[prev], &a[cur]);
}
cur++;
}
Swap(&a[keyi], &a[prev]);
keyi = prev;
return keyi;
}
void TestQuickSortNonR(int* a, int n)
{
Stack st;
StackInit(&st);
// 先入右，再入左，为了先取左
StackPush(&st, n - 1);
StackPush(&st, 0);
// 栈为空，排序就完成
while (!StackEmpty(&st))
{
int left = StackTop(&st);
StackPop(&st);
int right = StackTop(&st);
StackPop(&st);
// 快排单趟，排好一个值key，分割左右区间
int keyi = SingleQuickSort(a, left, right);
// [left, keyi - 1] keyi [ keyi + 1, right]
// key+1小于right，说明至少右区间还有两个数据，还需要入栈排序
if (keyi + 1 < right)
{
//先入右，再入左
StackPush(&st, right);
StackPush(&st, keyi + 1);
}
// left小于keyi - 1，说明至少左区间还有两个数据，还需要入栈排序
if (left < keyi - 1)
{
//先入右，再入左，组成左区间
StackPush(&st, keyi - 1);
StackPush(&st, left);
}
}
StackDestroy(&st);
}
3.5 归并排序
3.5.1 递归版
思路：
前提：
申请一个临时数组tmp，因为我们不能在原数组归并，不然会造成覆盖，需要在临时归并，在拷回原数组里。
由于创建了临时数组，我们就需要在创建一个子函数用来专门递归，不然每次调用都会申请空间子函数思路：
- 将序列从中间分成两个区间
[left，mid][mid + 1，right]，调用递归，直到只剩一个数据，一个数据就表示有序了。- 在把递归的两个区间进行合并，begin1和end2表示左序列，begin1和end2表示右序列，比较两个序列的值插入到临时数组里，其中肯定会有一个先结束，当其中一个序列拷贝完了就停止拷贝。
- 把剩下未合并的数据，全部放到tmp数组里。
- 最后在tmp数组的数据拷到原数组里。
// 子函数：用来递归
void _MergeSort(int* a, int left, int right, int* tmp)
{
if (left >= right)
return;
int mid = (left + right) >> 1;
// 分区[left, right] -> [left, mid] [mid + 1, right]
_MergeSort(a, left, mid, tmp);
_MergeSort(a, mid + 1, right, tmp);
// 标识归并两个有序的开始和结束
int begin1 = left, end1 = mid;
int begin2 = mid + 1, end2 = right;
// 两个序列合并，肯定会有一个先结束
int index = left;
while (begin1 <= end1 && begin2 <= end2)
{
if (a[begin1] < a[begin2])
{
tmp[index++] = a[begin1++];
}
else
{
tmp[index++] = a[begin2++];
}
}
// 处理剩下未合并完的数据，合并完的肯定不会进入循环
while (begin1 <= end1)
tmp[index++] = a[begin1++];
while (begin2 <= end2)
tmp[index++] = a[begin2++];
// tmp的数据拷贝到原数组，闭区间所以拷贝个数要加1
memmove(a + left, tmp + left, (right-left+1) * sizeof(int));
}
void MergeSort(int* a, int n)
{
// 创建临时数组，用来存放合并完的数据
int* tmp = (int*)malloc(n * sizeof(int));
_MergeSort(a, 0, n - 1, tmp);
free(tmp);
}
3.5.2 非递归版
- 同样也需要创建一个临时数组tmp，不能在原数据归并会覆盖。
- gap为每组数据个数，先从gap为1，一次两组数据归并，模拟递归最后一层的归并，如：[0,0]和[1,1]归并
- 通过每组个数(gap)推导出每组数据的区间，得出两组数据区间是
[i，i + gap - 1]，[i + gap，i + 2*gap - 1]。 - i需要加上2*gap，原来的区间已归并好了，所以需要指向下一次归并的起始位置，直到 i >= n结束，循环条件就要设为
i < n，表示排好差距为gap的多组数据。 - 排好差距为gap多组数据后，gap*2，下一趟需下一趟归并的一组数据个数翻倍，直到gap为gap >= n结束，>=就只有一个组数据，不能归并，循环条件就是
gap < n，就是说把未排序的数据分成两组数据，两组数据归并完就排好了序。 - 把临时数组的数据拷到原数组。
越界处理：
- 右区间不存在，直接跳出循环break，不进行归并。
- 右区间超过数据长度，进行修正，右区间结束标识n-1，就是最后一个数据的下标。
- 由于右区间不存在直接跳出的情况，tmp数组就会有随机值情况，并且左区间在原数组中也是有序的。
上面代码是把当前差距为gap的数据，全部归并好，在全部拷贝到原数据中。
这里就要修改成归并了多少，就拷多少，归并完直接拷贝，需要放进循环里面。
void MergeSortNonR(int* a, int n)
{
int* tmp = (int*)malloc(n * sizeof(int));
assert(tmp);
int gap = 1; // 每组的数据个数
// gap < n，就说明有两组数据才能归并，>=就说明只有一组数据
while (gap < n)
{
for (int i = 0; i < n; i += gap * 2)
{
// [i, i + gap - 1] [i + gap, i + gap * 2 - 1]
// 如：[0, 0] 和 [1, 1]......
// 标识需归并两组数据的范围
int begin1 = i, end1 = i + gap - 1;
int begin2 = i + gap, end2 = i + gap * 2 - 1;
// 右区间不存在
if (begin2 >= n)
break;
// 右区间超过了数据长度，修正成数据的长度
if (end2 >= n)
end2 = n - 1;
// 归并
int index = i;
while (begin1 <= end1 && begin2 <= end2)
{
if (a[begin1] < a[begin2])
{
tmp[index++] = a[begin1++];
}
else
{
tmp[index++] = a[begin2++];
}
}
// 剩余未归并完的数据全部放入tmp里
while (begin1 <= end1)
{
tmp[index++] = a[begin1++];
}
while (begin2 <= end2)
{
tmp[index++] = a[begin2++];
}
// 拷贝数据，归并了多少，就拷多少
for (int j = i; j <= end2; j++)
{
a[j] = tmp[j];
}
}
gap *= 2; // 下一趟归并的一组数据个数翻倍
}
}
3.6 选择排序
3.6.1 常规版（一次排好一个数）
实现思路：
- 假设起始位置（i）是最小的，通过变量（minIndex）保存该下标
- a[mini]从该下标（i）的下一个位置（i+1）开始去数据中依次比较
- 找到比自己小的数据，就把mini设为小的下标，循环还没有结束，所以还会用mini位置的值去和后面的值比较。
- 数据都比较完后，minIndex位置的值就是全部数据中最小的，如果minIndex不等于i（一开始i和minIndex的值一样，找到最小了的值后minIndex的会被改变），就需要交换两个位置的值，相等i的位置就是最小值，不用动。（加这个判断是防止数据是有序的，有序就没有必要交换）
- i+1，为了把排好的数据给排除掉，i再去在找数据中最小的值，重复以上操作，直到
i < n - 1结束。
注意：循环结束如果到i < n结束，在找数据时候就会越界如n = 1，i + 1就会越界，并且当已经排好了n-1个数后，最后一个元素已经是最大的元素，不需要再进行比较和交换操作了。
// 选择判断（常规版，选一个数）
void SelectSort(int* a, int n)
{
// n-1个数排好了，最后一个数就是正确的位置，不用在排序
for (int i = 0; i < n - 1; i++)
{
int minIndex = i;
for (int j = i + 1; j < n; j++)
{
if (a[j] < a[minIndex])
{
minIndex = j;
}
}
// minIndex改变了需要交换，minIndex的位置就是最小值
// 没有改变，i的位置就是最小值，不用动
if (i != minIndex)
{
Swap(&a[i], &a[minIndex]);
}
}
}
3.6.2 优化版（一次排好两个数）
实现思路：
- begin和end标识数据的区间，注意是闭区间
- 最小值（minIndex）从begin（最左边）开始放，最大值（maxIndex）从end（最右边）开始放。
- 排好两个数据后，begin往后走，end往前走，排除已排好的数据（缩小区间），直到begin和end相遇就表示排好了。
// 选择判断（优化版，两个数）
void SelectSort_double(int* a, int n)
{
int begin = 0, end = n - 1;
while (begin < end)
{
// 一次选出最小值和最大值
int minIndex = begin, maxIndex = end;
for (int i = begin; i <= end; i++)
{
if (a[i] < a[minIndex])
{
minIndex = i;
}
if (a[i] > a[maxIndex])
{
maxIndex = i;
}
}
if (minIndex != begin)
Swap(&a[minIndex], &a[begin]);
// max和begin重叠，maxIndex的值已被换到minIndex位置
if (maxIndex == begin)
maxIndex = minIndex;
if (maxIndex != end)
Swap(&a[maxIndex], &a[end]);
begin++;
end--;
}
}
3.7 冒泡排序
实现思路：
- 每次就排好一个数，第一个数据和第二数据先比较在交换，小的在前，大的在后，第二个数据在第三个数据交换，一直反复下去。a[j] > a[j + 1]
- 该过程会把小数据（不是最小，只是相比下小数据）交换到前面，直到交换到最后一个数据，最大的数据就在最后面了（比他小的数据都交换在他前面了），为了防止后面数据都是有序，用一个变量标识下（交换了没有），如果后面数据有序继续比较和交换效率低，我们做一下判断，如果有序（没有交换），我们就可以直接跳出。
- 排好一个数后，就排除已排好的数据（缩小区间），直到只剩最后一个数，
j < n - 1 - i。 - 一共只需要排n-1个数，和常规选择排序一个情况，n-1个数有序了，剩余的1个数肯定是有序的，就等于自己和自己比较在交换，无意义。
// 冒泡排序
void BubbleSort(int* a, int n)
{
for (int i = 0; i < n - 1; i++)
{
// 标识是否交换，默认是没交换
int exchange = 1;
for (int j = 0; j < n - 1 - i; j++)
{
if (a[j] > a[j + 1])
{
Swap(&a[j], &a[j + 1]);
exchange = 0; // 数据交换了
}
}
// 数据没有交换，表示有序，就直接跳出
if (exchange)
break;
}
}
3.8 计数排序
- 计算出数据的范围区间，最大值减去最小值，这是相对范围
min——max，绝对范围是0——max，太浪费空间。 - 创建一个计数数组count，因为是闭区间，大小是
max-min+1，用来存放数据出现的次数，初始化都是0。 - 统计每个数出现的次数，放入到数据减去最小值的下标位置（计数数组的相对位置）。
- 把数据写到原数组里，只写次数不为0的，出现了几次就写入几个数据，数据通过count的下标+最小值还原出来。
// 计数排序
void CountSort(int* a, int n)
{
// 找到最小值和最大值
int min = a[0], max = a[0];
for (int i = 1; i < n; i++)
{
if (a[i] < min)
min = a[i];
if (a[i] > max)
max = a[i];
}
// 计算出相对范围
int range = max - min + 1;
// 创建计数数组，初始化为全0
// 方法1
int* count = (int*)malloc(range * sizeof(int));
assert(count);
memset(count, 0, range * sizeof(int));
// 方法2，calloc申请的空间默认都是NULL或0（根据指针类型决定）
//int* count = (int*)calloc(range * sizeof(int));
// 统计每个数出现的次数
for (int i = 0; i < n; i++)
{
count[a[i] - min]++;
}
// 把数组写入原数组
// 数据出现了多少次就写入多少个值
int j = 0;
for (int i = 0; i < range; i++)
{
while (count[i]--)
{
a[j++] = i + min;
}
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
