手撕九大排序算法——面试必备！！！
Posted Bitdancing
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了手撕九大排序算法——面试必备！！！相关的知识，希望对你有一定的参考价值。
本文的排序算法都用升序来讲解。
常见的排序算法有：
- 插入排序 —— 直接插入排序 && 希尔排序
- 选择排序 —— 选择排序 && 堆排序
- 交换排序 —— 冒泡排序 && 快速排序
- 归并排序
- 基数排序
- 计数排序 （非比较排序）
插入排序
插入排序就像摸一张牌插入到正确的位置。
假设 [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)
带你整理面试过程中常考的九大排序算法
总结：大厂面试常考手撕代码 —— JavaScript排序算法（冒泡排序选择排序插入排序快速排序）
前端开发必备技能 —— 数据结构 && 算法 && 手撕JavaScript/ES6