本文的排序算法都用升序来讲解。

常见的排序算法有:

* 插入排序 —— 直接插入排序 && 希尔排序
* 选择排序 —— 选择排序 && 堆排序
* 交换排序 —— 冒泡排序 && 快速排序
* 归并排序
* 基数排序
* 计数排序 (非比较排序)
<>插入排序

插入排序就像摸一张牌插入到正确的位置。

假设 [0, end] 有序, end+1 位置的插入到 [0, end] 中, 让 [0, end+1] 有序。
void InsertSort(int* a, int n) { for (int i = 0; i < n - 1; ++i) { //单趟排序 int
end= i; int tmp = a[end + 1]; while (end >= 0) { if (a[end] > tmp) { a[end + 1]
= a[end]; --end; } else { break; } } a[end + 1] = tmp; } }
时间复杂度:O(N^2)
最坏情况下移动:1 + 2 + …… + n-1
最好情况:完全顺序有序 时间复杂度 是 O(N)
稳定性: 稳定

<>希尔排序

希尔排序是在直接插入排序基础上的优化排序算法。

* 进行预排序,让数组接近有序。预排序,就是分组(gap > 1)
* 直接插入排序(gap == 1)

void ShellSort(int* a, int n) { int gap = n; while (gap > 1) { gap = gap / 2;
//间隔为gap的多组数据同时排序 for (int i = 0; i < n - gap; ++i) { //一个gap里的一组数据 int end = i;
int tmp = a[end + gap]; while (end >= 0) { if (a[end] > tmp) { a[end + gap] = a[
end]; end -= gap; } else { break; } } a[end + gap] = tmp; } } }
时间复杂度:
gap = gap/ 2 时, 是logN
gap = gap/3 + 1时, 是log3N

当gap很大的时候,预排序的时间复杂度是 O(N)。
当gap很小的时候,数组已经接近有序了,时间复杂度是 O(N)。

所以时间复杂度是 O(logNN) 或者 O(log3NN)
平均的时间复杂度是O(N^1.3)

<>直接选择排序

基本思想:每一次从待排序的数据元素中选出最小(或最大)的一个元素,存放在序列的起始位置,直到全部待排序的数据元素排完。

* 在元素集合 array[i] ~ array[n-1]中选择最大(小)的元素
* 若它不是这组元素中的最后一个(第一个)元素,则将它与这组元素中的最后一个(第一个)元素交换。
* 在剩余的array[i] ~array[n-2] (array[i+1] ~ array[n-1])集合中,重复上述步骤,直到集合剩余1个元素。
下面实现的是选出最大和最小的数,一起进行排序。
void SelectSort(int* a, int n) { int begin = 0, end = n - 1; while (begin < end
) { int mini = begin, maxi = end; //单趟选择排序 //找出最大,最小的下标 for (int i = begin; i <=
end; i++) { if (a[i] < a[mini]) { mini = i; } if (a[i] > a[maxi]) { maxi = i; }
} //最小值、最大值分别和begin、end交换 Swap(&a[begin], &a[mini]);
//如果begin和maxi重合,要把mini赋值给maxi if (begin == maxi) { maxi = mini; } Swap(&a[end],
&a[maxi]); ++begin; --end; } }
时间复杂度: O(N^2)

<>堆排序

堆的逻辑结构:完全二叉树
物理结构:数组(层序)

通过观察可以得出父子结点的关系:
leftchild = parent *2 + 1
rightchild = parent *2 + 2
parent = (child - 1) / 2

大堆中,树中所有的父亲都大于等于孩子。小堆中,树中所有的父亲都小于等于孩子。

<>向下调整算法

在这里,我们先引入向下调整算法(建堆用),以建小堆为例。这里说一句很重要的事情!!!向下调整算法建立小堆的前提条件是
左右子树都是小堆。算法思想是从根结点开始,选出左右子树中小的那一个,和父结点比较,如果比父结点要小就交换,然后继续向下进行调整,知道叶子节点终止。

建大堆代码
// 建大堆 void AdjustDown(int* a, int n, int root) { int parent = root; int child
= parent * 2 + 1; //默认是左节点 while (child < n) { //选出左右孩子中大的那一个 if (child + 1 < n
&& a[child + 1] > a[child]) { ++child; } if (a[child] > a[parent]) { Swap(&a[
child], &a[parent]); parent = child; child = parent * 2 + 1; } else { break; } }
}
<>自底而上的建堆方式

向下调整算法是建堆的单趟步骤。如果左右子树不是小堆,是不能直接使用向下调整算法的。这时候我们应该怎么办呢?
—— 倒着从最后一棵子树开始调整。 但是再想一想,倒着走最后一棵子树叶子是不需要调整的,所以最后决定从倒数最后一个非叶子的子树开始调整。

下面是建堆的代码
// 建堆 for (int i = (n - 1 - 1) / 2; i >= 0; --i) { AdjustDown(a, n, i); }
到了这时候,会有一个疑问,排升序,是建大堆还是建小堆?

如果是建小堆,最小数在堆顶,被选出来之后,用剩余的树再去选数,剩下树的结构都乱了,需要重新建堆,建堆的时间复杂度是O(N),这样不是不可以,但是堆排序就没有效率的优势了,整体的时间复杂度是O(N^2)。

正确的方法是建大堆。第一个数和最后一个数交换,不把这个数当作树的一部分,前n-1个数向下调整,选出次小的数,再和倒数第二个数交换……

实现的代码
void HeapSort(int* a, int n) { // 建堆 时间复杂度:O(N) for (int i = (n - 1 - 1) / 2; i
>= 0; --i) { AdjustDwon(a, n, i); } // 排升序,建大堆还是小堆?建大堆 int end = n - 1; while (
end> 0) { Swap(&a[0], &a[end]); AdjustDwon(a, end, 0); --end; } }
时间复杂度: O(N*log N)

<>冒泡排序

这个是最基本的排序算法,两层循环,外层循环代表排序的趟数,内层循环代表比较次数,这里设置一个变量区分数组是否已经有序。
void BubbleSort(int* a, int n) { for (int i = 0; i < n - 1; i++) { int exchange
= 0; for (int j = 0; j < n - i - 1; j++) { if (a[j] > a[j + 1]) { Swap(&a[j], &a
[j + 1]); exchange = 1; } } if (!exchange) break; } }
时间复杂度:O(N*N)
最好情况:O(N)

<>快速排序

基本思想:选择一个key关键字(一般是第一个或者是最后一个),左边的数都比key要小,右边的key都大。

之后只需要对左边的数和右边的数进行排序。
对于单趟排序有三种常见的方法,分别是挖坑法,左右指针,前后指针。

快排在有序的情况下情况最坏,最坏情况下退化成冒泡排序,时间复杂度是O(N^2)。针对这种情况,使用三数取中和小区间优化的方法对原有的快速排序进行优化。
三数取中避免出现key的值是最小或者最大的情况。
代码:
int GetMidIndex(int* a, int left, int right) { int mid = (left + right) >> 1;
if (a[left] < a[mid]) { if (a[mid] < a[right]) { return mid; } else if (a[left]
> a[right]) { return left; } else { return right; } } else //a[left] > a[mid] {
if (a[mid] > a[right]) { return mid; } else if (a[left] > a[right]) { return
right; } else { return left; } }
这里的快速排序采用的是分治算法,到每组的数分到后面的时候,调用的栈帧是以2的指数次增长的,所以采用小区间采用插入排序的方法。
下面,我们只需要考虑单趟排序,前面已经提到过单趟排序有三种方法,下面会详细介绍。
函数接口
void QuickSort(int* a, int left, int right) { if (left <= right) { return; }
int keyindex = PartSort1(a, left, right); //[left, keyIndex - 1]
keyIndex[keyIndex + 1, right] //QuickSort(a, left, keyindex - 1);
//QuickSort(a, keyindex + 1, right); //小区间优化 if (keyindex - 1 - left > 10) {
QuickSort(a, left, keyindex - 1); } else { InsertSort(a + left, keyindex - left)
; } if (right - (keyindex + 1) > 10) { QuickSort(a, keyindex + 1, right); } else
{ InsertSort(a + keyindex + 1, right - (keynidex + 1) + 1); } }
<>挖坑法

* 右边找比key的值小的数,放到左边,小的数放到左边的坑里,自己形成新的坑位
* 左边找比key的值大的数,放到右边,大的数放到右边的坑里,自己形成新的坑位
代码实现
int PartSort1(int* a, int left, int right) { int index = GetMidIndex(a, left,
right); Swap(&a[left], &a[index]); int begin = left, end = right; int pivot =
begin; int key = a[begin]; while (begin < end) { //右边找小,放到左边 while (begin < end
&& a[end] >= key) { --end; } //小的放到左边的坑位,自己原本的位置形成新的坑位 a[pivot] = a[end]; pivot
= end; //左边找大,放到右边 while (begin < end && a[begin] <= key) { ++begin; }
//大的放到右边的坑位,自己形成新的坑位 a[pivot] = a[begin]; pivot = begin; } a[pivot] = key;
return pivot; }
<>左右指针法

基本思想:

* begin从左边开始找大,end从右边开始找小,找到一大一小就交换。
* 最后,交换begin和keyi的值,返回相遇的下标 int PartSort2(int* a, int left, int right) { int
index= GetMidIndex(a, left, right); Swap(&a[left], &a[index]); int begin = left,
end= right; int keyi = begin; while (begin < end) { //右边找小 while (begin < end
&& a[end] >= a[keyi]) { --end; } //左边找大 while (begin < end && a[begin] <= a[keyi
]) { ++begin; } //交换 Swap(&a[begin], &a[end]); } Swap(&a[begin], &a[keyi]);
return begin; }
<>前后指针法

* cur找比key小的数,每次遇到比key小的值就停下来,++prev,交换prev和cur位置的值,++cur。
* 交换keyi和prev对应的值。
int PartSort3(int* a, int left, int right) { int index = GetMidIndex(a, left,
right); Swap(&a[left], &a[index]); int keyi = left; int prev = left, cur = left
+ 1; while (cur <= right) { if (a[cur] < a[keyi] && ++prev != cur) { Swap(&a[
prev], &a[cur]); } ++cur; } Swap(&a[keyi], &a[prev]); return prev; }
<>归并排序

基本思想:

归并排序(MERGE-SORT)是建立在归并操作上的一种有效的排序算法,该算法是采用分治法的一个非常典型的应用,将已有的子序列合并,得到完全有序的序列;即先使每个子序列有序,再使子序列段间有序,若将两个有序表合并成一个有序表,称为二路归并。

<>递归解法
void _MergeSort(int* a, int left, int right, int* tmp) { if (left >= right)
return; //分解 int mid = (right + left) >> 1; //[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++]; } //拷贝回到原数组 for (int i = left; i <= right; ++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); }
<>非递归解法

设置gap来模拟数组分解之后归并的过程,gap从1开始,每次乘2递增。

void MergeSortNonR(int* a, int n) { int* tmp = (int*)malloc(sizeof(int) * n);
int gap = 1; //每组数据的个数 while (gap < n) { 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 (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++]; } } 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; } free(tmp); }
<>基数排序

123 45 12 9 88 43

依次分别取他们的个位、十位、百位……排序

个位: 12 123 43 45 88 9

十位:9 12 123 43 45 88

百位:以此类推

只能对整数进行排序,实际中这个排序没啥意义。

<>计数排序

计数排序是一种非比较排序,思想很巧,适用范围具有局限性,适合范围集中的一组整形数据排序。
void CountSort(int* a, int n) { int max = a[0], min = a[0]; for (int i = 0; i <
n; ++i) { if (a[i] > max) { max = a[i]; } if (a[i] < min) { min = a[i]; } } int
range= max - min + 1; int* count = (int*)malloc(sizeof(int)*range); memset(
count, 0, sizeof(int)*range); // 统计次数 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; } } free(count); }

技术
友情链接
码工具
Toolsou
API参考文档
云服务器优惠
阿里云优惠券
腾讯云优惠券
华为云优惠券
站点信息
问题反馈
邮箱:ixiaoyang8@qq.com
QQ群:766591547
关注微信