八大排序（详细分析+动图演示）
Posted 小倪同学 -_-
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了八大排序（详细分析+动图演示）相关的知识，希望对你有一定的参考价值。
直接插入排序
动图演示：
基本思想：
把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为
止，得到一个新的有序序列。
代码实现：
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)
{
// 寻找比tmp小的数据
if (a[end]>tmp)
{
a[end + 1] = a[end];
end--;
}
else
{
break;
}
}
// 将tmp插入比tmp小的数据后或首位
a[end + 1] = tmp;
}
}
直接插入排序的特性总结：
- 元素集合越接近有序，直接插入排序算法的时间效率越高
- 时间复杂度：O(N^2)
- 空间复杂度：O(1)，它是一种稳定的排序算法
- 稳定性：稳定
稳定性：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次
序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排
序算法是稳定的；否则称为不稳定的。
希尔排序
动图演示：
基本思想：
先选定一个小于N的数gap，把待排序文件中所有记录分成个组，所有距离为gap的元素分在同一组内，并对每一组内的记录进行排序。然后将gap/3+1的值赋给gap，重复上述分组和排序的工作。当到达=1时，所有记录在统一组内排好序。
先令gap等于5，此时距离为5的元素分为一组，分别对每一组进行直接插入排序
再令gap=gap/3+1=2,此时距离为2的元素分为一组，对每一组进行插入排序
再进行上述操作，此时gap为1，所有数据被分为一组，对该组数据进行插入排序
代码实现：
void ShellSort(int* a, int n)
{
int gap = n;
while (gap > 1)
{
gap = gap / 3 + 1;// 减少排序组数
// 一趟直接排序
for (int i = 0; i < n - gap; i++)
{
int end = i;
int tmp = a[end + gap];
while (end >= 0)
{
if (tmp < a[end])
{
a[end + gap] = a[end];
end -= gap;
}
else
{
break;
}
}
a[end + gap] = tmp;
}
}
}
希尔排序的特性总结：
- 希尔排序是对直接插入排序的优化
- 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就会很快.
- 通过大量的试验统计，时间复杂度大约为O（N^1.3）
- 稳定性：不稳定
直接选择排序
动图演示：
基本思想：
- 在元素集合中选出最大(小)的数据元素
- 若它不是这组元素中的最后一个(第一个)元素，则将它与这组元素中的最后一个（第一个）元素交换
- 在剩余的集合中，重复上述步骤，直到集合剩余1个元素
代码实现：
void SelectSort2(int* a, int n)
{
int i = 0,j=0;
for (i = 0; i < n-1; i++)
{
int min = i;// 取出第一个元素下标
// 找到最小值的下标
for (j = i + 1; j < n; j++)
{
if (a[j]<min)
{
min = j;
}
}
Swap(&a[min], &a[i]);
}
}
为了提高效率，我们可以一次遍历找到最大值和最小值
代码：
void Swap(int* a, int* b)
{
int tmp = *a;
*a = *b;
*b = tmp;
}
void SelectSort(int* a, int n)
{
int begin = 0;
int end = n - 1;
while (begin < end)
{
// 记录最大值和最小值坐标
int min = begin, max = end;
// 找出最大和最小值的坐标
for (int i = begin; i < end; i++)
{
if (a[min]>a[i])
min = i;
if (a[max] < a[i])
max = i;
}
Swap(&a[begin], &a[min]);
// 防止最大值位于序列开头，被最小值交换
if (max == begin)
{
max = min;
}
Swap(&a[end], &a[max]);
begin++;
end--;
}
}
直接选择排序的特性总结：
- 直接选择排序思考非常好理解，但是效率不是很好。实际中很少使用
- 时间复杂度：O(N^2)
- 空间复杂度：O(1)
- 稳定性：不稳定
堆排序
动图演示：
基本思想：
要想使用堆排序首先要建堆，注意降序需要建大堆，升序要建小堆
如何建堆呢？
找到最后一个非叶结点，将该结点从后往前依次进行下述操作：（这里以建大堆为例）将传入的结点当做父节点，比较其两个子节点，将子节点与父节点比较，如果比父结点大就交换，并将原先子节点的位置当成父节点，重复上述操作。如果满足父结点比子结点大就结束操作。
代码如下：
// 向下调整
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 test()
{
// 从最后一个非叶子结点先前调整
for (int i = (n - 1 - 1) / 2; i >= 0; i--)
{
AdjustDown(a,n,i);
}
}
建好堆，下面就要进行排序（以升序为例），这里以图解加文字的方式帮助大家理解
代码实现：
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--;
}
}
堆排序的特性总结：
- 堆排序使用堆来选数，效率就高了很多
- 时间复杂度：O(N*logN)
- 空间复杂度：O(1)
- 稳定性：不稳定
冒泡排序
动图演示：
基本思想：
相邻两个元素比较，不相同就交换，直到最后一个元素
代码实现：
void BubbleSort(int* a, int n)
{
for (int end = n; end > 0; --end)
{
int exchange = 1;
//一趟冒泡排序，把最大值放在结尾
for (int i = 1; i < end; i++)
{
if (a[i - 1]>a[i])
{
Swap(&a[i - 1], &a[i]);
exchange = 0;
}
}
//一趟冒泡排序中没有交换就退出
if (exchange)
break;
}
}
冒泡排序的特性总结：
- 冒泡排序是一种非常容易理解的排序
- 时间复杂度：O(N^2)
- 空间复杂度：O(1)
- 稳定性：稳定
计数排序
基本思路：
计数排序不是通过比较数据的大小来排序的，而是通过统计数组中相同元素个数，然后再将元素按顺序返回给原数组中。
当arr数组中元素很大时再从零开始会造成很大的空间浪费，如数组元素为101,103 ,104,106,我们总不能开辟106个空间吧。为了摆脱上述情况我们需要用到映射：先遍历数组找到最小值min和最大值max,把[min,max]范围映射到范围[0,max-min+1]上。
代码实现：
void CountSort(int* a, int n)
{
int min = a[0];
int 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;
int* count = (int*)calloc(range, sizeof(int));
//统计次数
for (int i = 0; i < n; i++)
{
count[a[i] - min]++;
}
//排序
int i = 0;
for (int j = 0; j < range; j++)
{
while (count[j]--)
{
a[i++] = j + min;
}
}
}
快排
hoare版本
一趟操作的动图演示：
基本思路：
- 先选出一个key（一般是最左边）
- 再创建left和right分别代表数组第一个数据和最后一个数据
- 让right先往前走，当right找到比key小的数据时，left开始往后走，left找到比key大的数据时停下，交换right和left的数据，再重复之前操作直到left和right相遇，这时再交换key和left。
- 通过前几步操作后key的前面都是比它小的元素，后面都是比它大的元素，这时再将key左右两边分别进行该操作，递归下去直到左右序列只有一个数据，或是左右序列不存在完成排序
代码实现：
int PartSort(int* a, int left, int right)
{
int keyi = left;
while (left < right)
{
//左边找比keyi小
while (left<right&&a[right]>a[keyi])
{
right--;
}
//右边找keyi大
while (left < right&&a[left] < a[keyi])
{
left++;
}
//交换找到的大小
Swap(&a[right], &a[left]);
}
Swap(&a[left], &a[keyi]);
return left;
}
void QuickSort(int* a, int left, int right)
{
if (left >= right)
return;
int keyi = PartSort(a, left, right);
QuickSort(a, left, keyi - 1);
QuickSort(a, keyi + 1, right);
}
挖坑法
一趟操作的动图演示：
基本思路：
- 取出一个数据key（一般是第一个）作为坑位
- 创建left和right分别代表数组第一个数据和最后一个数据
- 让right先往前走，当right找到比key小的数据时，取出该数据放入原坑位中，并让其形成新的坑位，接着让left往后走，当left找到比key大的数据时，取出该数据放入right形成的坑位中，自己形成新坑。直到left和right相遇，将数据key填入最后形成的坑位中
- key左右两边分别进行该操作，递归下去直到左右序列只有一个数据，或是左右序列不存在完成排序
int PartSort(int* a, int left, int right)
{
int key = a[left];
int hole = left;
while (left < right)
{
//右边找小，填坑，自己形成新坑
while (left<right&&a[right]>key)
{
right--;
}
a[hole] = a[right];
hole = right;
//左边找大，填坑，自己形成新坑
while (left < right&&a[left] < key)
{
left++;
}
a[hole] = a[left];
hole = left;
}
a[hole] = key;
return hole;
}
void QuickSort(int* a, int left, int right)
{
if (left >= right)
return;
int keyi = PartSort(a, left, right);
QuickSort(a, left, keyi - 1);
QuickSort(a, keyi + 1, right);
}
前后指针法
一趟操作的动图演示：
基本思路：
- 选出一个元素key（一般是第一个），再创建两个指针prev,cur
- 起始时，prev指针指向序列开头，cur指针指向prev+1.
- cur开始移动，直到cur指向的元素比prev小，prev往后移动一位，如果prev指向的位置不同于cur指向的，交换两个位置上的元素，直到cur到数组末尾，最后交换key和prev指向的数据
- key左右两边分别进行该操作，递归下去直到左右序列只有一个数据，或是左右序列不存在完成排序
代码实现：
int PartSort(int* a, int left, int right)
{
int keyi = left;
int prev = left;
int cur = prev + 1;
while (cur <= right)
{
// 当cur指向数据小于keyi指向数据且prev
// 不同于cur时交换prev和cur指向的数据
if (a[cur] < a[keyi] && ++prev != cur)
Swap(&a[prev], &a[cur]);
++cur;
}
Swap(&a[keyi], &a[prev]);
return prev;
}
void QuickSort(int* a, int left, int right)
{
if (left >= right)
return;
int keyi = PartSort(a, left, right);
QuickSort(a, left, keyi - 1);
QuickSort(a, keyi + 1, right);
}
非递归版
基本思路：
将递归改为非递归一般有两种方法，一是循环，二是利用数据结构，这里利用了数据结构——栈
先将数组左右下标入栈，接下来每趟排序从栈中取出下标，排序完成后将key左半部分和右半部分下标入栈，重复上述操作直到左右序列只有一个数据，或是左右序列不存在取消入栈。当栈为空时结束排序。
代码实现：
void QuickSortNonR(int* a, int left, int right)
{
ST st;
StackInit(&st);
//将左右下标入堆
StackPush(&st, right);
StackPush(&st, left);
while (!StackEmpty(&st))
{
//取出堆顶数据作为左，右下标
int begin = StackTop(&st);
StackPop(&st);
int end = StackTop(&st);
StackPop(&st);
int keyi = PartSort3(a, begin, end);
//将右半部分入堆
if (keyi + 1 以上是关于八大排序（详细分析+动图演示）的主要内容，如果未能解决你的问题，请参考以下文章
八大排序算法——堆排序（动图演示 思路分析 实例代码java 复杂度分析）
数据结构初阶第九篇——八大经典排序算法总结（图解+动图演示+代码实现+八大排序比较）
数据结构初阶第九篇——八大经典排序算法总结（图解+动图演示+代码实现+八大排序比较）
算法漫游指北（第七篇）:冒泡排序冒泡排序算法描述动图演示代码实现过程分析时间复杂度和选择排序算法描述动图演示代码实现过程分析时间复杂度