一、前言

在上一篇文章中，我们已经学习了五种排序算法，还没看过的小伙伴可以去看一下：传送门
今天要讲的是八大排序中剩下的三种，这三种排序算法用的是非常多的，需要好好掌握。
下面介绍的排序算法均以排升序为例。

二、快速排序

快排的思想是分治，就是选定一个基准值，使这个值的左边都小于等于它，右边都大于等于它，然后递归处理左右子区间。

因此快排的关键就在于如何选定基准值和如何实现划分左右区间。
关于前者，我们可以选左端点，也可以选右端点，也可以选中点，还可以随机选。我们不妨先以左端点为基准值，来继续下面的分析。
关于后者，其实有很多种方法可以实现划分，这里只讲几种比较经典的。

1. hoare 版

hoare是快排的发明者，我们先来学习他的划分方法。
给几分钟认真观察下面的动图。

以排升序为例，我们要使左边都小于等于key，右边都大于等于key，就可以利用左右双指针来维护这段区间，右指针找小，左指针找大，找到后交换，再继续找，直至左右指针相遇为止。最后把key与相遇处的值交换即可。

先来解释下为什么选左端点为基准值的时候，要右指针先走。
先说结论，这样做是为了保证最后左右指针相遇处的值比key小，从而保证key与相遇位置的值交换后，左边都小于key，右边都大于key。同理如果以右端点为基准值，就要左指针先走。
再来解释下为什么会这样。左右指针相遇无非两种情况，要么左遇右，要么右遇左。
如果左遇右，因为右指针先走，所以右指针先停。由于右指针是找小，所以右指针停的位置的值比key小，所以相遇处的值就比key小。
如果右遇左，也就是说右指针还没停，因为右指针是先走的，一种情况是左指针根本没动过，还停留在左端点；另一种情况是左指针动过，但是上一轮左右指针指向的值交换后，左指针位置的值就比key小了。所以上述两种情况都能保证key与左右指针相遇处的值交换后，左边都小于key，右边都大于key。

来看看代码怎么写。

void QuickSort1(int a[], int l, int r)
{if (l >= r) return;int keyi = l;//左端为key，右端先走int i = l, j = r;//保存一下左右指针的初始位置while (l < r){while (l < r && a[r] >= a[keyi]) r--;//右边找小while (l < r && a[l] <= a[keyi]) l++;//左边找大swap(&a[l], &a[r]);}swap(&a[keyi], &a[l]);keyi = l;QuickSort1(a, i, keyi - 1);QuickSort1(a, keyi + 1, j);
}

第一趟结束后，因为key的左边都小于等于它，右边都大于等于它，所以key已经在最终排好序的位置上了。故只需递归[l, keyi - 1]和[keyi + 1, r]即可。

2. 挖坑法

这种方法比较好理解，直接上动图和代码。

void QuickSort2(int a[], int l, int r)
{if (l >= r) return;int key = a[l];int hole = l;int i = l, j = r;while (l < r){while (l < r && a[r] >= key) r--;a[hole] = a[r];hole = r;while (l < r && a[l] <= key) l++;a[hole] = a[l];hole = l;}a[hole] = key;QuickSort2(a, i, hole - 1);QuickSort2(a, hole + 1, j);
}

3. 前后指针法

void QuickSort3(int a[], int l, int r)
{if (l >= r) return;int keyi = l;int prev = l, cur = l + 1;while (cur <= r){if (a[cur] < a[keyi])swap(&a[++prev], &a[cur]);cur++;}swap(&a[prev], &a[keyi]);QuickSort3(a, l, prev - 1);QuickSort3(a, prev + 1, r);
}

以上三种方法效率并无差异，只是实现划分的思想不同，挑一种自己好理解的掌握就行。个人比较喜欢 hoare 版的快排。

4. 快排的非递归实现

众所周知，函数栈帧是建立在栈空间上的，而栈空间的大小是有限的，如果递归过深可能会导致栈溢出。因此算法的非递归实现具有很重要的意义。

我们可以利用数据结构中的栈来模拟递归的过程。

void QuickSortNonR(int a[], int l, int r)
{ST st;STInit(&st);STPush(&st, r);STPush(&st, l);while (!STEmpty(&st)){l = STTop(&st);STPop(&st);r = STTop(&st);STPop(&st);//这里是hoare版的划分思想int keyi = l;int i = l, j = r;while (i < j){while (i < j && a[j] >= a[keyi]) j--;while (i < j && a[i] <= a[keyi]) i++;swap(&a[i], &a[j]);}swap(&a[keyi], &a[i]);keyi = i;//如果区间长度==2//它的两个子区间长度就分别为1和0，故不用继续递归if (r - keyi > 2)//r - (keyi + 1) + 1{STPush(&st, r);STPush(&st, keyi + 1);}if (keyi - l > 2)//(keyi - 1) - l + 1{STPush(&st, keyi - 1);STPush(&st, l);}}STDestroy(&st);
}

由于 C 语言的特性，我们只能自己实现栈这个数据结构，具体可以看我这篇文章：【数据结构】栈和队列

另外，快排的非递归还可以用队列实现，有兴趣的可以自己尝试。
提示：栈模拟的是dfs，队列模拟的是bfs。

5. 时空复杂度分析

快排的平均时间复杂度是O(NlogN)，数组有序的情况下会退化成O(N^2)。
空间复杂度是O(logN)。

快排是不稳定的排序算法。

三、归并排序

归并排序的思想是分治，就是先递归到最后一层，此时每个子区间都只有一个数，即每个子区间都有序，每两个子区间再合并成一个有序区间，最后扫尾。

完成这个过程需要一个辅助数组，另外要开辟logN层栈帧，故空间复杂度为O(N)。

归并排序的时间复杂度是O(NlogN)。
归并排序是稳定的排序算法。

来看看代码怎么写。

1. 递归实现

void _MergeSort(int a[], int l, int r, int* tmp)
{if (l >= r) return;int mid = l + r >> 1;_MergeSort(a, l, mid, tmp);_MergeSort(a, mid + 1, r, tmp);int i = l, j = mid + 1, k = l;while (i <= mid && j <= r){if (a[i] <= a[j]) tmp[k++] = a[i++];else tmp[k++] = a[j++];}while (i <= mid) tmp[k++] = a[i++];while (j <= r) tmp[k++] = a[j++];for (int i = l; i <= r; i++) a[i] = tmp[i];
}void MergeSort(int a[], int n)
{int* tmp = (int*)malloc(sizeof(int) * n);_MergeSort(a, 0, n - 1, tmp);free(tmp);
}

2. 非递归实现

void MergeSortNonR(int a[], int n)
{int* tmp = (int*)malloc(sizeof(int) * n);int gap = 1;while (gap < n){int j = 0;for (int i = 0; i < n; i += 2 * gap){// 每组的合并数据int begin1 = i, end1 = i + gap - 1;int begin2 = i + gap, end2 = i + 2 * gap - 1;if (end1 >= n || begin2 >= n){break;}// 修正if (end2 >= n){end2 = n - 1;}while (begin1 <= end1 && begin2 <= end2){if (a[begin1] <= a[begin2]){tmp[j++] = a[begin1++];}else{tmp[j++] = a[begin2++];}}while (begin1 <= end1){tmp[j++] = a[begin1++];}while (begin2 <= end2){tmp[j++] = a[begin2++];}// 归并一组，拷贝一组memcpy(a + i, tmp + i, sizeof(int) * (end2 - i + 1));}gap *= 2;}free(tmp);
}

归并排序的缺点在于O(N)的空间复杂度和拷贝数组的消耗。
因此归并排序的思想更多的是用于外部排序。

四、计数排序

计数排序的思想是相对映射。

直接来看代码怎么实现。

void CountSort(int a[], int n)
{int min = 0, max = 0;for (int i = 0; i < n; i++){if (a[i] < min) min = a[i];if (a[i] > max) max = a[i];}int range = max - min + 1;int* count = (int*)calloc(range, sizeof(int));for (int i = 0; i < n; i++){int idx = a[i] - min;count[idx]++;}for (int i = 0, j = 0; i < range; i++){while (count[i]--){a[j++] = i + min;}}free(count);
}

时间复杂度 O(N + range)
空间复杂度 O(range)

缺陷：
1.只适合用于数据范围较为集中的情况。
如果range过大，时间复杂度和空间复杂度都会很大，时空效率都很一般。
但是在range较小的情况下，时间复杂度可以做到线性，空间复杂度可以做到常数级。
2.只能用于整型数据的排序。
因为计数排序是用计数数组的下标来相对映射原数组每个元素的值，而数组下标只能是整型。

总之，计数排序在排序范围较集中的整型数据时，效率非常好，大幅优于其他排序算法。