跳至主要內容

七大排序（代码+动图演示）

xlc520algorithmalgorithm大约 33 分钟约 9789 字

七大排序（代码+动图演示）

1.排序的概念及其运用

1.1 排序的概念

排序：所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。

稳定性：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次 序保持不变，即在原序列中，r[i]=r[j]，且 r[i]在 r[j]之前，而在排序后的序列中，r[i]仍在 r[j]之前，则称这种排 序算法是稳定的；否则称为不稳定的。

稳定性的意义

：在根据多种属性进行排序时会有巨大的意义。比如我们先对学生按照学号进行了排序，再对学生进行了按照成绩进行排序，此时学号和成绩成为了两种决定因素，如果我们在按照成绩进行排序时，所使用的算法是不具有稳定性的，那么在对成绩排序后，之前根据学号进行的排序就没有意义了，此时就会出现相同成绩，但是学号靠后的在前面，反之，如果我们选择的排序具有稳定性，那么成绩相同，学号靠前的应该在前面。

内部排序：数据元素全部放在内存中的排序。

外部排序：数据元素太多不能同时放在内存中，根据排序过程的要求不能在内外存之间移动数据的排序。**一般数据是存储在磁盘中的。 **

区分内外排序：

排序类型数据存储访问速度支持的访问形式
内排序数据在内存中（数组）快下标随机访问
外排序数据在磁盘中，数据量很大慢串行访问

1.2 排序的运用

下面就是按价格对手机进行排序：

image-20220424103625642
image-20220424103625642

下面是根据综合得分对大学进行排名：

image-20220424103843298
image-20220424103843298

1.3 常见的排序算法

image-20220424104112902
image-20220424104112902

2. 常见排序算法的实现

2.1 插入排序

2.1.1 基本思想

直接插入排序是一种简单的插入排序法，其基本思想是：

把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列 。

简单来说就是：有一个有序区间，插入一个数据，依旧保持它有序。

2.1.2 直接插入排序

当插入第 i(i>=1)个元素时，前面的 array[0],array[1],……,array[i-1]已经排好序，此时用 array[i]的排序码与 array[i-1] ,array[i-2] ,……的排序码顺序进行比较，找到插入位置即将 array[i]插入，原来位置上的元素顺序后移。

动图展示：

20210223174254141
20210223174254141

代码实现：（此处排的是升序）

void InsertSort(int *a,int n)
{
 for (int i = 0; i < n-1;i++)//end:[0:n-2]  end+1:[1:n-1]
 {
  int end = i;
  //[0,end]有序 把[end+1]插入进去，保持它依旧有序
  int tmp = a[end + 1];
  while (end >= 0)
  {
   if (tmp < a[end])//降序就是把 < 变为 > 
   {
    a[end + 1] = a[end];
    --end;
   }
   else
   {
    break;
   }
  }
  a[end + 1] = tmp;
  //此处有两种情况，第一种就是数据到了应该插入的位置（非a[0]），另一种就是数据要插入到a[0]的位置
 }
}

直接插入排序的特性总结：

  1. 元素集合越接近有序，直接插入排序算法的时间效率越高
  2. 时间复杂度：O(N^2) 最坏的情况（逆序）：1 + 2 + ······ + N 时间复杂度：O(N2) 最好：（有序）O(N)
  3. 空间复杂度：O(1)，它是一种稳定的排序算法
  4. 稳定性：稳定

2.1.3 希尔排序

希尔排序（ShellSort）又称为“缩小增量排序”。是 1959 年由 D.L.Shell 提出来的。该方法的基本思想是：* *先将整个待排元素序列分割成若干个子序列（由相隔某个“增量”的元素组成的）分别进行直接插入排序，然后依次缩减增量再进行排序，待整个序列中的元素基本有序（增量足够小）时，再对全体元素进行一次直接插入排序 **。因为直接插入排序在元素基本有序的情况下（接近最好情况），效率是很高的，因此希尔排序在时间效率上比前两种方法有较大提高。

具体做法：首先确定一组增量 d0，d1，d2，d3，……,dt-1()其中 n>d0>d1>……>dt-1=1),对于 i=0,1,2,……,t-1,依次进行下面的各趟处理: 根据当前增量 di 将 n 个元素分成 di 个组,每组中元素的下标相隔为 di;再对各组中元素进行直接插入排序.

动图展示：

v2-f9616f6892819e579a2d4ab10256a732_b
v2-f9616f6892819e579a2d4ab10256a732_b

1、预排序：大的数更快的到后面去，小的数更快的到前面去，尽可能地接近有序。

举例：

image-20220417091054918
image-20220417091054918

gap 为几，就将数字划分为几组数据，然后分别对这几组数据进行插入排序，例如在上面地例子中，首先对 9、5、8、5 进行插入排序，然后对 1、7、4 进行插入排序，然后再对 2、6、3 进行插入排序。这就是预排序。

问：gap 的大小和预排序后的数据有什么关系？

答：如果 gap 越小，数据跳跃越慢，但是预排序后的数据就越接近有序；如果 gap 越大，大的数据可以更快的到达最后，小的数据可以更快的到达前面，但它越不接近有序，只能说是相对有序。

问：希尔排序就一定比直接插入排序快吗？

答：不一定，当所给数组本来就是升序或者接近升序的时候，进行的预排序就相当于是无用功，相当于是白做的，此时的效率就不如直接插入排序了。当然，这种情况是很少的，一般所给的数据都是乱序或者接近逆序的，所以这种情况一般不去考虑。

2、直接插入排序

直接插入排序就是 gap 为 1 时候的排序，就是直接插入排序，由于此时地数据已经接近有序，所以插入排序起来更为容易。

问：插入排序的效率在哪体现呢？

答：在间隔 gap 个数据进行插入排序时，相当于一次跨越 gap 个数据进行移动，这样从本质上来看相对于直接插入排序节省了很多次循环所花费的时间，下面举个例子来看：

image-20220417092754508
image-20220417092754508

在经过一次 gap 为 3 的插入排序后，较小的三个数字 3、2、1 已经排到了最前面，中间的三个数字 6、5、4 已经到了中间，较大的三个数字 9、8、7 已经到了最后，这样我们在进行直接插入排序的时候，1 只需要移动两次就能到达最前面，而如果没有进行 gap 为 3 的那次预排序的话，1 需要移动 8 次进行 8 次循环才能到达它需要到达的位置，这就是希尔排序提高的效率所在。

代码：

//希尔排序:传统写法
void ShellSort(int* a, int n)
{
 int gap = n;
 while (gap > 1)//这个地方不能是>=1，因为经过后面的控制后，gap始终大于1，如果是>=1，就会陷入死循环
 {
  gap = gap / 3 + 1;//保证最后一次一定是1，即最后有一次直接插入排序
  for (int k = 0; k < gap; k++)
  {
   for (int i = k; i < n - gap; i += gap)//为什么是n - gap?因为最后一个end是n-1-gap,end+gap一定小于n
   {
    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;
   }
  }
 }
}

下面是希尔排序的优化写法：

将四层循环变为 3 层循环，当然，效率并没有提升，只是将代码的循环层数减少了一层，两者时间复杂度其实并没有太大的区别

//希尔排序：优化写法
void ShellSort(int* a, int n)
{
 int gap = n;
 while (gap > 1)//这个地方不能是>=1，因为经过后面的控制后，gap始终大于1，如果是>=1，就会陷入死循环
 {
  gap =gap/3 + 1;//保证最后一次一定是1，即最后有一次直接插入排序
  for (int i = 0; i < n - gap; ++i)//为什么是n - gap?因为最后一个end是n-1-gap,end+gap一定小于n
  {
   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;
  }
 }
}

希尔排序的特性总结：

  1. 希尔排序是对直接插入排序的优化。

  2. 当 gap > 1 时都是预排序，目的是让数组更接近于有序。当 gap == 1 时，数组已经接近有序的了，这样就 会很快。这样整体而言，可以达到优化的效果。我们实现后可以进行性能测试的对比。

  3. 希尔排序的时间复杂度不好计算，因为 gap 的取值方法很多，导致很难去计算，因此在好些书中给出的 希尔排序的时间复杂度都不固定：

    《数据结构(C 语言版)》— 严蔚敏

image-20220417104317401
image-20220417104317401

《数据结构-用面相对象方法与 C++描述》— 殷人昆

image-20220417104337855
image-20220417104337855

因为我们的 gap 是按照 Knuth 提出的方式取值的，而且 Knuth 进行了大量的实验统计，我们就暂时按照：==O(n1.25)到 O(1.6*n1.25) ==来算

  1. 稳定性：不稳定

如果我们自己算希尔排序的时间复杂度的话：

预排序：

gap 很大时，数据跳的很快，差不多是 O(N)，内层循环几乎忽略不计，跳跃的很快（每次跳跃 gap 次）。

gap 很小时，数据很接近有序，几乎不需要挪动，此时差不多也是 O(N)。

最外层循环：

总共循环 log3N 次

所以我们粗略进行计算的时候时间复杂度：O(N*log3N)

2.2 选择排序

2.2.1 基本思想

每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完 。

2.2.2 直接选择排序

  • 在元素集合 array[i]–array[n-1]中选择关键码最大(小)的数据元素
  • 若它不是这组元素中的最后一个(第一个)元素，则将它与这组元素中的最后一个（第一个）元素交换
  • 在剩余的 array[i]–array[n-2]（array[i+1]–array[n-1]）集合中，重复上述步骤，直到集合剩余 1 个元素

动态图：

SEL
SEL

直接选择排序的特性总结：

  1. 直接选择排序思考非常好理解，但是效率不是很好。实际中很少使用
  2. 时间复杂度：O(N^2)
  3. 空间复杂度：O(1)
  4. 稳定性：不稳定

选择排序代码实现：

void SelectSort(int* a, int n)
{
 
 int left = 0;
 int right = n - 1;
 while (left < right)
 {
  int maxi = left;
  int mini = left;
        //下面为什么是左开右闭区间？因为maxi和mini已经假设left是最小或者最大的数了，所以不必再包含left了，但是rightb
  for (int i = left + 1; i <= right; i++)
  {
   if (a[i] < a[mini])
   {
    mini = i;
   }
   if (a[i] > a[maxi])
   {
    maxi = i;
   }
  }
  Swap(&a[left], &a[mini]);
  //如果left和maxi重叠，在将mini和left交换之后，mini此时就等于maxi
  if (left == maxi)
  {
   maxi = mini;
  }
  Swap(&a[right], &a[maxi]);
  left++;
  right--;
 }
}

2.2.3 堆排序

堆排序(Heapsort)是指利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种。它是 通过堆来进行选择数据。需要注意的是排升序要建大堆，排降序建小堆。

2.3 交换排序

基本思想：所谓交换，就是根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置，交换排序的特点是：将键值较大的记录向序列的尾部移动，键值较小的记录向序列的前部移动。

2.3.1 冒泡排序

1145616330
1145616330

代码：

void BubbleSort(int* a, int n)
{
 for (int i = 0; i < n; i++)
 {
        int exange = 0;
  for (int j = 0; j < n - i - 1; j++)
  {
   if (a[j] > a[j + 1])
   {
    Swap(&a[j], &a[j + 1]);
                exange = 1;
   }
  }
        if(exange == 0)//当有序的时候直接退出
            break;
 }
}

冒泡排序的特性总结：

1.冒泡排序是一种非常容易理解的排序

2.时间复杂度：O(N^2) 最好情况：顺序有序：O(N)（最少得执行一次内层循环）

3.空间复杂度：O(1)

4.稳定性：稳定

冒泡排序与插入排序的比较

相比之下，插入排序会更好一些，例如下面的这种情况：

1 2 3 4 5 6 8 7

这种情况下插入排序要比较 8 此，但是冒泡排序要比较 7 + 6 = 13 次。当然。此时的时间复杂度都是 O(N)。

但是在局部有序的情况下：

3 4 2 8 7 9 5 9

冒泡排序的优化基本不会体现出什么价值，但是插入排序却能充分利用局部有序的情况，使比较次数减少。

总结：如果是顺序有序的情况，那么插入和冒泡是一样的；但是如果是局部有序，或者接近有序，那么插入的适应性更好，比较次数更少。

2.3.2 快速排序

2.3.2.1 快速排序的代码实现（三种思路）

快速排序是 Hoare 于 1962 年提出的一种二叉树结构的交换排序方法，其基本思想为：* *任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止 **。

// 假设按照升序对array数组中[left, right)区间中的元素进行排序
void QuickSort(int array[], int left, int right)
{
 if (right - left <= 1)
  return;

 // 按照基准值对array数组的 [left, right)区间中的元素进行划分
 int div = partion(array, left, right);

 // 划分成功后以div为边界形成了左右两部分 [left, div) 和 [div+1, right)
 // 递归排[left, div)
 QuickSort(array, left, div);

 // 递归排[div+1, right)
 QuickSort(array, div + 1, right);
}

上述为快速排序递归实现的主框架，发现与二叉树前序遍历规则非常像，我们在写递归框架时可想想二叉树前序遍历规则即可快速写出来，后续只需分析如何按照基准值来对区间中数据进行划分的方式即可。

将区间按照基准值划分为左右两半部分的常见方式有：

  1. hoare 版本

    单趟排序：选出一个 key，一般是第一个数或者最后一个数

    要求：左边的值都比 key 要小，右边的值都比 key 要大。

    动图展示：

    hoare
    hoare

    图像展示：

    image-20220417161341875
    image-20220417161341875

    总结：R 找比 key 小的值，L 找比 key 大的值，找到后交换，再重复上述过程，相遇之后，把相遇位置的值跟 key 交换。

    问：当数字数目为偶数的时候，是否会出现不相遇的情况或者如何保证相遇位置的值一定比 key 小呢？

    答：不会，因为 R 总是先于 L 移动，总会找到一个比 key 小的位置，即使 L 的后面不是一个小于 key 的数字，此时的 R 也会到达 L 所处的位置，因为之前经过交换，此时一定是一个比 key 小的数字。简单来收就是只有两种情况：R 去碰 L，或者 L 去碰 R，无论哪一种，两者相遇的地方都是一个比 key 小的位置。

    问：如果右边作 key，那么第一轮排序后会变成什么样子的？

    答：第一轮排序后如图所示： image-20220417170238685

    此时要注意必须让左边先走，为了保证相遇点一定是一个比 key 大的数据。

    快速排序单趟排序写法思路：

    初始代码：

    int PartSort(int *a,int left,int right)//快速排序单趟排序
{
 int keyi = left;
 while (left < right)
 {
  //右边找小
  while (a[right] > a[keyi])
  {
   right--;
  }
  //左边找大
  while (a[left] < a[keyi])
  {
   left++;
  }
        Swap(&a[left], &a[right]);
 }
    Swap(&a[keyi], &a[left]);
    return left;//返回相遇的位置
}

很明显，上面的代码并不完善，无法处理两种情况，即下面的两种情况：

1 2 3 4 5

5 5 2 3 5在这种情况下就会陷入死循环，因为 5 不大于 5，right 始终无法进行–操作，left 也同样无法进行++操作，此时就会陷入死循环。

此时进行优化，在相等的时候也要进行–操作：

   int PartSort(int *a,int left,int right)//快速排序单趟排序
   {
    int keyi = left;
    while (left < right)
    {
     //右边找小
     while (a[right] >= a[keyi])
     {
      right--;
     }
     //左边找大
     while (a[left] <= a[keyi])
     {
      left++;
     }
           Swap(&a[left], &a[right]);
    }
       Swap(&a[keyi], &a[left]);
       return left;//返回相遇的位置
   }

此时又出现了新的问题：如果 right 找不到比 key 小的，就会出现越界的风险，所以在进行a[right]>=a[keyi] 条件判断的前面还要加上一个条件，下面是代码的进一步优化：（最终版）

int PartSort(int *a,int left,int right)//快速排序单趟排序
{
 int keyi = left;
 while (left < right)
 {
  //右边找小
  while (left<right && a[right] >= a[keyi])
  {
   right--;
  }
  //左边找大
  while (left < right && a[left] <= a[keyi])
  {
   left++;
  }
        Swap(&a[left], &a[right]);
 }
    Swap(&a[keyi], &a[left]);
    return left;//返回相遇的位置
}

此时进行接下来的分析及操作：

此时 keyi 所在的数据就不需要再进行移动了，已经放在了正确的位置。如果 keyi 的左边有序，右边再有序，那么整体就是有序的 。此时就需要运用分治的思想，此时分别对右边进行单趟排序的递归，直到所有数据都有序，然后重复上面的数据，直到只有一个数据时为止，此时退出递归，整体就是有序的。

快速排序主函数代码：

   void QuickSort(int* a,int begin,int end)
{
    //当出现错位或者二者相等的时候就停止
    if (begin >= end)
     return;
   
    int keyi = PartSort(a, begin, end);
    //分割出了两个子区间：[begin,keyi-1]keyi[keyi+1,end]
    QuickSort(a, begin, keyi - 1);
    QuickSort(a, keyi+1, end);
   }

问：return 的条件判断为什么是begin >= end？而不能只是一个==呢？

答：比如当进入这个函数时，begin = 0，end = 2，keyi = 1，此时就会出现两个区间，就是[0,0]和[2,1] ，如果只是相等的话，判断前面的条件自然没有什么问题，但是判断后面的不存在的区间时就不行了。

  1. 挖坑法

    动图展示：

    挖坑法
    挖坑法

    代码：

    int PartSort2(int* a, int left, int right)
{
 int key = a[left];
 int hole = left;//记录坑的下标
 while (left < right)
 {
  while (left<right&& a[right] >= key)//从右边找小于key的
  {
   right--;
  }
  a[hole] = a[right];//把找到的值放到坑位上去
  hole = right;//形成新的坑
  while (left<right&&a[left] <= key)//从左边找大于key的
  {
   left++;
  }
  a[hole] = a[left];//把找到的值放到坑位上去
  hole = left;//形成新的坑
 }
 a[left] = key;//将key放到相遇的位置上去（相遇的位置一定是坑）
 return left;//返回相遇位置的下标
}

    问：挖坑法和 hoare 有什么区别吗？两个的效率是否一样？挖坑法是否就一定比 hoare 方法好呢？

    答：挖坑法和 hoare 方法没有本质的区别，两个的时间复杂度也都是一样的，不存在谁优谁劣的问题，两者的好坏并没有严格的限定，挖坑法相对 hoare 方法来说，更容易理解，hoare 方法过于抽象，有些不太好理解。需要注意的是：在使用两种方法经过第一轮排序后形成的结果并不一定是相同的，或者说二者大多数情况下都是不相同的，只有少数情况下才是相同的。 **

  2. 前后指针法

    动图展示：

    前后指针
    前后指针

    代码：

    //left作keyi
int PartSort3(int* a, int left, int right)
{
 int keyi = left;
 int prev = left;
 int cur = left + 1;
 while (cur <= right)
 {
  //下面这一行代码的作用：当cur遇到比a[keyi]小的值后++prev，并且防止自己跟自己进行交换
  if (a[cur] < a[keyi] && a[++prev]!= a[cur])
   Swap(&a[cur], &a[prev]);

  cur++;
 }
 Swap(&a[prev], &a[keyi]);//将a[prev]和a[keyi]进行交换
 return prev;
}
//right作keyi
int PartSort3(int* a, int left, int right)
{
 int keyi = right;
 int cur = left;
 int prev = left - 1;
 while (cur<right)
 {
  if (a[cur] < a[keyi] && a[++prev] != a[cur])
  {
   Swap(&a[cur], &a[prev]);
  }
  cur++;
 }
 Swap(&a[++prev], &a[keyi]);
 return prev;
}

    prev 和 cur 的关系：

    1、cur 还没遇到比 key 大的值时，prev 紧跟着 cur，一前一后。

    2、cur 遇到比 key 大的值时，prev 和 cur 之间间隔着一段比 key 大的值的区间。

2.3.2.2 时间复杂度

快速排序的时间复杂度：

最好情况：每次选的都是中位数 O(N*log2N)

image-20220419170635866
image-20220419170635866

最坏情况：每次选的 key 是最小的或最大的 O(N2)

2.3.2.3 快速排序的优化

1.随机选 key

2.三数选中

int GetMidIndex(int*a,int  left,int  right)
{
 int mid = left + (right- left) / 2;
 if (a[left] < a[mid])// left mid
 {
  if (a[mid] < a[right])//left mid right
  {
   return mid;
  }
  else if (a[left] > a[right])//right left mid
  {
   return left;
  }
  else//left right mid
  {
   return right;
  }
 }
 else//mid   left
 {
  if (a[right] > a[left])//mid left right
  {
   return left;
  }
  else if (a[mid] < a[right])//mid right left
  {
   return right;
  }
  else//right mid left
  {
   return mid;
  }
 }
}

//left作keyi
int PartSort3(int* a, int left, int right)
{
 int midi = GetMidIndex(a, left, right);
    Swap(&a[midi], &a[left]);
 int keyi = left;
 int prev = left;
 int cur = left + 1;
 while (cur <= right)
 {
  //下面这一行代码的作用：当cur遇到比a[keyi]小的值后++prev，并且防止自己跟自己进行交换
  if (a[cur] < a[keyi] && a[++prev]!= a[cur])
   Swap(&a[cur], &a[prev]);

  cur++;
 }
 Swap(&a[prev], &a[keyi]);//将a[prev]和a[keyi]进行交换
 return prev;
}

注意：三数取中法依然无法完全解决针对某种特殊情况序列复杂度变为 O(n2)的情况。

3.小区间优化

image-20220419192053842
image-20220419192053842

快排递归调用就是展开简化图就是一个二叉树，我们从上图中可以看到，快速排序的主要花销在数据比较少的时候，就是 begin 和 end 之间的数比较少或者 begin 和 end 相等的时候，这个时候的递归次数相当多，我们可以在数字比较少的时候去调用其它的排序函数，以此来达到优化开快排的目的。 **

简而言之：区间很小时，不再使用递归划分的思路让它有序，而是直接使用插入排序对小区间排序，减少递归调用。

代码：

void QuickSort(int* a,int begin,int end)
{
 //当出现错位或者二者相等的时候就停止
 if (begin >= end)
  return;
 
 //小区间直接使用插入排序控制有序
 if (end - begin <= 10)
 {
  InsertSort(a + begin, end - begin + 1);
 }
 int keyi = PartSort3(a, begin, end);
 //分割出了两个子区间：[begin,keyi-1]keyi[keyi+1,end]
 QuickSort(a, begin, keyi - 1);
 QuickSort(a, keyi+1, end);
}

2.3.2.3 快速排序非递归

两种思路进行实现：

2.3.2.3.1 栈模拟递归实现

思路：

**将需要使用到的下标放到栈上临时存储（为什么只存下标？因为 PartSort() 函数只需要用到函数名和下标），然后使用栈的性质，每当拿出一对下标时，将得到的新下标依次压入栈中，这样，始终都是先对右边的下标进行排序，模拟了递归的性质。 **

image-20220422195516422
image-20220422195516422

代码实现：

//快速排序的非递归形式1：通过栈来实现
void QuickSort3(int* a, int begin, int end)
{
 ST st;
 StackInit(&st);
 StackPush(&st, begin);
 StackPush(&st, end);
 while (!StackEmpty(&st))
 {
  int end = StackTop(&st);
  StackPop(&st);
  int begin = StackTop(&st);
  StackPop(&st);
  int keyi = PartSort(a, begin, end);
  //[begin , keyi - 1] [keyi+1,end]
  if (begin < keyi - 1)
  {
   StackPush(&st, begin);
   StackPush(&st, keyi - 1);
  }
  if (keyi + 1 < end)
  {
   StackPush(&st, keyi + 1);
   StackPush(&st, end);
  }
 }
 StackDestory(&st);
}
2.2.2.3.2 队列模拟二叉树遍历实现

思路：

将需要使用到的下标放到队列中来进行临时存储，每次从队列中拿出一对下标时，又将新形成的下标放入到队列中去，直到队列为空时停止。

图示：

image-20220422204533821
image-20220422204533821

代码：

//快速排序的非递归形式1：通过队列来实现
void QuickSort3(int* a, int begin, int end)
{
 Queue q;
 QueueInit(&q);
 QueuePush(&q, begin);
 QueuePush(&q, end);
 while (!QueueEmpty(&q))
 {
  int left = QueueFront(&q);
  QueuePop(&q);
  int right = QueueFront(&q);
  QueuePop(&q);
  int keyi = PartSort(a, left, end);//[left,keyi-1][keyi+1,right]
  if (left < keyi - 1)
  {
   QueuePush(&q, left);
   QueuePush(&q, keyi - 1);
  }
  if (keyi + 1 < right)
  {
   QueuePush(&q, keyi + 1);
   QueuePush(&q, right);
  }
 }
 QueueDestory(&q);
}

2.4 归并排序

2.4.1 基本思想

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

核心步骤：

image-20220422210059119
image-20220422210059119
查看源图像
查看源图像

2.4.2 归并排序的实现

2.4.2.1 方法一：递归版

分解思路：

image-20220423161317000
image-20220423161317000

归并思路：

image-20220423162141519
image-20220423162141519

代码：

//归并排序
void _MergeSort(int* a, int begin, int end,int*tmp)//辅助函数
{
 if (begin >= end)
 {
  return;
 }
 int mid = (begin + end) / 2;
 //[begin,mid][mid+1,end]
 _MergeSort(a, begin, mid, tmp);
 _MergeSort(a, mid + 1, end, tmp);
 //此处必须这样划分区间，如果划分为[begin,mid-1][mid,end]时就会出现死循环的现象,比如[1,2]
 //归并
 int begin1 = begin, end1 = mid;//begin1和end1用来控制第一个区间
 int begin2 = mid + 1, end2 = end;//begin2和end2用来控制第二个区间
 int index = begin;//下标每次都从begin位置开始
 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++];
 }
 memcpy(a+begin, tmp+begin, (end - begin + 1) * sizeof(int));//运用内存拷贝函数
}
void MergeSort(int* a,int n)
{
 int* tmp = (int*)malloc(sizeof(int) * n);//开辟临时数组空间
 assert(tmp);//防止开辟失败
 _MergeSort(a, 0, n - 1,tmp);
 free(tmp);
}
2.4.2.2 方法二：非递归版

第一个版本：

void MergeSort(int* a, int n)
{
 int* tmp = (int*)malloc(sizeof(int) * n);
 assert(tmp);
 int gap = 1;
 while (gap<n)
 {
  for (int i = 0;i<n;i+=2*gap)//为什么在gap前面有一个2，因为是两组数据进行归并
  {
   int begin1 = i, end1 = i + gap - 1;
   int begin2 = i+gap, end2 = i + 2 * gap - 1;
   int index = i;
            //printf("[%d,%d] [%d,%d]\n", begin1 , end1 , begin2 , end2);
   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++];
   }
  }
  memcpy(a, tmp, n*sizeof(int));
  gap *= 2;
 }
 free(tmp);
}

上面的代码经过打印，在测试非 2 的幂次方个数目的数组时程序就会出现问题，例如当我们测试 10 个数时看一下打印的下标：

image-20220423185520974
image-20220423185520974

发生了越界（总共有 10 个数字，下标最大为 9，所以程序出现了问题）

下面将进行一次修正，将越界的下标数字强制修改为 n-1，修正部分的代码如下所示：

if (end1 >= n)
{
 end1 = n - 1;
}
if (begin2 >= n)
{
 begin2 = n - 1;
}
if (end2 >= n)
{
 end2 = n - 1;
}

修正后打印结果为：

image-20220423190011161
image-20220423190011161

**此时程序依旧不对，为什么？因为 index 会发生越界，当下标为[8,9]和[9,9] 的时候，程序会在while(begin1 <= end1 && begin2 <= end2) 这个位置进入循环两次，然后此时 index 会变成 10（最开始的 index 为 8），然后后面因为begin2==end2会再次进入循环，此时的 index 就会出现越界访问的现象。 **

此处进行分析：如果 end1 越界，我们是可以修正的，如果 end2 越界，begin2 没有越界，我们也是可以修正 end2 的，如果 begin2 越界了，那么第二个区间就会直接不存在，此时需要再对上面的代码进行修改。

if (end1 >= n)
{
 end1 = n - 1;
}
if (begin2 >= n)
{
 begin2 = n;
    end2 = n - 1;
}
if (end2 >= n)
{
 end2 = n - 1;
}

修改的部分就是：如果 begin2 越界，直接让[begin2,end2]这个区间不存在即可。

完整代码如下所示：

void MergeSort(int* a, int n)
{
 int* tmp = (int*)malloc(sizeof(int) * n);
 assert(tmp);
 int gap = 1;
 while (gap<n)
 {
  for (int i = 0;i<n;i+=2*gap)//为什么在gap前面有一个2，因为是两组数据进行归并
  {
   int begin1 = i, end1 = i + gap - 1;
   int begin2 = i+gap, end2 = i + 2 * gap - 1;
   //end1越界
   if (end1 >= n)
   {
    end1 = n - 1;
   }
   //begin2越界
   if (begin2 >= n)
   {
    begin2 = n;
    end2 = n - 1;
   }
   //只有end2越界
   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++];
   }
  }
  memcpy(a, tmp, n*sizeof(int));
  gap *= 2;
 }
 free(tmp);
}

2.4.3 归并排序的外排序

2.4.3.1 归并外排序的思想

思想：当所要排序的的数据量太多或者文件太大，无法直接在内存里排序，而需要依赖外部设备时，就会使用到外部排序。

算法描述：

  1. 将所要排序的文件平均分割成若干个可以加载到内存中的小文件
  2. 将每个小文件中的数据加载到内存中，使用快速排序法或者其它排序方法将每个小文件中的数据排成有序
  3. 将内存中有序的数据重新写回到文件中，此时达到了文件中归并的先决条件

  1. 归并思路如下图所示：

    image-20220425150548589
    image-20220425150548589

    上图中的(1)和(2)和(3)和(4)分别是第一次归并、第二次归并、第三次归并和第四次归并，后面的没有再列举出来。

    注意：实际中的归并思路有很多种，并不是只有这一种，此处把这个思路列举出来只是为了后面的应用举例。

2.4.3.2 归并外排序的实现

归并排序外排序函数代码：

//归并排序的文件排序
//file1和file2是要被归并的文件，mfile是存放归并后的数据的文件
void _MergeFile(const char*file1, const char*file2,const char* mfile)
{
    //将三个文件打开
 FILE* fout1 = fopen(file1, "r");
 if (fout1 == NULL)
 {
  printf("打开文件失败！\n");
  exit(-1);
 }

 FILE* fout2 = fopen(file2, "r");
 if (fout2 == NULL)
 {
  printf("打开文件失败！\n");
  exit(-1);
 }

 FILE* fin = fopen(mfile, "w");
 if (fin == NULL)
 {
  printf("打开文件失败！\n");
  exit(-1);
 }
 //开始归并
 int num1, num2;//存储file1和file2中读取的数据
    //先从文件中读取出一个数据，ret1是为了判断是否读取结束，如果等于EOF就说明已经读取结束
 int ret1 = fscanf(fout1, "%d\n", &num1);
 int ret2 = fscanf(fout2, "%d\n", &num2);
    //存放新的数据
 while (ret1!= EOF && ret2 != EOF)//当有一个文件读取结束时读取就结束
 {
        //此处是因为要排升序，所以将小的数据读入新的文件中
  if (num1 < num2)
  {
   fprintf(fin, "%d\n", num1);//将小的数据num1读入新的文件中
   ret1 = fscanf(fout1, "%d\n", &num1);//重新读入新的数据
  }
  else
  {
   fprintf(fin, "%d\n", num2);//同上
   ret2 = fscanf(fout2, "%d\n", &num2);
  }
 }
    //如果存在未读取完的文件，将剩余的数据读取到新的文件mfile中
 while (ret1!=EOF)
 {
  fprintf(fin, "%d\n", num1);
  ret1 = fscanf(fout1, "%d\n", &num1);
 }
 while (ret2!=EOF)
 {
  fprintf(fin, "%d\n", num2);
  ret2 = fscanf(fout1, "%d\n", &num2);
 }
 fclose(fout1);
 fclose(fout2);
 fclose(fin);
}

2.4.3.3 归并外排序使用举例

这个例子中有文件 file，此文件中总共是有 100 个数据，我们是要将它分成 10 组，每组数据有 10 个数据，每个数据放在一个文件中，文件名从1到10 ，然后存放新文件的名字最开始是12，表示这个文件要存放文件 1 和 2 归并后的数据，同理，后面的 123 就是存放文件 12 和 3 归并后的数据。

代码实现：

void MergeSortFile(const char* file)//此处的file是要被排序的文件
{
 FILE* fout = fopen(file, "r");
 if (fout == NULL)
 {
  printf("打开文件失败！\n");
  exit(-1);
 }
 //分割成一段一段数据，内存排序后写到小文件
 int n = 10;
 int a[10];
 int i = 0;
 int num = 0;
 char subfile[20] = { 0 };
 int filei = 1;
 while (fscanf(fout, "%d\n", &num) != EOF)
 {
  if (i < n-1)//前9个数据进去
  {
   a[i++] = num;
  }
  else
  {
   a[i] = num;//这是第10个数据
   QuickSort(a, 0, n - 1);
   sprintf(subfile, "%d", filei++);
   FILE* fin = fopen(subfile, "w");
   if (fin == NULL)
   {
    printf("打开文件失败\n");
    exit(-1);
   }
   for (int i = 0; i < n; i++)
   {
    fprintf(fin, "%d\n", a[i]);
   }
   fclose(fin);
   i = 0;
   memset(a, 0, sizeof(int)*n);
  }
 }
 //利用互相归并到文件，实现整体有序
 //····
 char mfile[100] = "12";
 char file1[100] = "1";
 char file2[100] = "2";
 for (int i = 2; i <= n; i++)
 {
  //读取file1和file2，进行归并出mfile
  _MergeFile(file1, file2, mfile);//将file1和file2进行归并到mfile中 
  strcpy(file1, mfile);//此处将mfile的名字复制给file1
  sprintf(file2, "%d", i+1);
  sprintf(mfile, "%s%d", mfile,i + 1);
 }
 fclose(fout);
}

2.4.4 归并排序的特性总结

  1. 归并的缺点在于需要 O(N)的空间复杂度，归并排序的思考更多的是解决在磁盘中的外排序问题。
  2. 时间复杂度：O(N*logN) 如何理解归并排序的时间复杂度？ image-20220423205120424
  3. 空间复杂度：O(N) 注意：实际上应该是 O(N + log2N) （N 是开辟的数组的空间，log2N 是开辟栈帧的层数（递归版本，非递归就没有），log2N 太小，可以看成是常数，几乎忽略不计，所以就是 O(N)）
  4. 稳定性：稳定

2.5 七大排序性能测试比较

2.5.1 测试比较代码

代码：

// 测试排序的性能对比
void TestOP()
{
 srand((unsigned)time(0));
 const int N = 100000;
 int* a1 = (int*)malloc(sizeof(int) * N);
 int* a2 = (int*)malloc(sizeof(int) * N);
 int* a3 = (int*)malloc(sizeof(int) * N);
 int* a4 = (int*)malloc(sizeof(int) * N);
 int* a5 = (int*)malloc(sizeof(int) * N);
 int* a6 = (int*)malloc(sizeof(int) * N);
 int* a7 = (int*)malloc(sizeof(int) * N);
 assert(a1);
 assert(a2);
 assert(a3);
 assert(a4);
 assert(a5);
 assert(a6);
 assert(a7);

 for (int i = 0; i<N; i++)
 {
  a1[i] = rand();
  a1[i] = N-i;
  a2[i] = a1[i];
  a3[i] = a1[i];
  a4[i] = a1[i];
  a5[i] = a1[i];
  a6[i] = a1[i];
  a7[i] = a1[i];
 }
 int begin1 = clock();
 InsertSort(a1, N);
 int end1 = clock();
 int begin2 = clock();
 ShellSort(a2, N);
 int end2 = clock();
 int begin3 = clock();
 SelectSort(a3, N);
 int end3 = clock();
 int begin4 = clock();
 HeapSort(a4, N);
 int end4 = clock();
 int begin5 = clock();
 QuickSort(a5, 0, N - 1);
 int end5 = clock();
 int begin6 = clock();
 MergeSort(a6, N);
 int end6 = clock();
 int begin7 = clock();
 BubbleSort(a7, N);
 int end7 = clock();
 printf("InsertSort:%d\n", end1 - begin1);
 printf("ShellSort:%d\n", end2 - begin2);
 printf("SelectSort:%d\n", end3 - begin3);
 printf("HeapSort:%d\n", end4 - begin4);
 printf("QuickSort:%d\n", end5 - begin5);
 printf("MergeSort:%d\n", end6 - begin6);
 printf("BubbleSort:%d\n", end7 - begin7);

 free(a1);
 free(a2);
 free(a3);
 free(a4);
 free(a5);
 free(a6);
 free(a7);
}

2.5.2 测试比较结果

注意：在 VS2019release 版本下进行测试，此时编译器进行了一系列优化。

当 N 为 10000 时：

image-20220423221717247
image-20220423221717247

当 N 为 100000 时：

image-20220423221808048
image-20220423221808048

此时继续进行测试快速排序、堆排序、希尔排序、归并排序：

当 N 为 1000000：

image-20220423221907517
image-20220423221907517

当 N 为 10000000：

image-20220423221948756
image-20220423221948756

当 N 为 20000000：

image-20220423222352147
image-20220423222352147

2.6 非比较排序

2.6.1 计数排序

2.6.1.1 计数排序的思想

思想：计数排序又称为鸽巢原理，是对哈希直接定址法的变形应用。 操作步骤：

  1. 统计相同元素出现次数
  2. 根据统计的结果将序列回收到原来的序列中

图示： image-20220424121029857

代码：

void CountSort(int* a,int n)
{
 //求出最大值和最小值
 int max = a[0];
 int min = a[0];
 for (int i = 1; i < n; i++)
 {
  if (a[i] > max)
  {
   max = a[i];
  }
  if (a[i] < min)
  {
   min = a[i];
  }
 }
 int size = max - min + 1;//映射表数组的大小
 //建立映射数组
 int* countArray = (int*)calloc(size,sizeof(int));
 assert(countArray);
 //计数
 for (int i = 0; i < n; i++)
 {
  countArray[a[i] - min]++;
 }
 //放回到原来的数组中：排序
 int j = 0;//j用来记录原来数组的下标
 for (int i = 0; i < size; i++)//i用来记录映射表数组元素的小标
 {
  while(countArray[i]--)
  {
   a[j++] = i + min;
  }
 }
}
2.6.1.2 计数排序的复杂度

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

空间复杂度：O(range)

注意：range = max - min +1

说明：计数排序适用于范围集中的数据

注意：计数排序支持负数但是不支持浮点数、字符串等。

3.排序算法复杂度及稳定性分析

image-20220424150445356
image-20220424150445356

稳定性分析：

直接插入排序：稳定。

希尔排序：不稳定。相同的数可能被分配到不同的 gap 组中。

选择排序：不稳定。如下图所示：

image-20220424150957648
image-20220424150957648

在上图中，选出最小的数字 1，和前面的 3 交换之后两个 3 的相对位置就发生了交换，说明选择排序是不稳定的。

堆排序：不稳定。如下图所示：

image-20220424151402859
image-20220424151402859

此时是一个大堆，我们想要得到的是升序的数据，此时如果将 8 和 4 进行交换后，此时两个 8 的相对位置就发生了改变，所以堆排序不具有稳定性。

冒泡排序：稳定。

快速排序：不稳定。因为最终 keyi 要放到中间去。

归并排序：稳定。因为在归并的时候，左边的先下就始终是稳定的。

图表总结：

排序方法平均情况最好情况最坏情况辅助空间稳定性
冒泡排序O(n2)O(n2)O(n2)O(1)稳定
简单选择排序O(n2)O(n2)O(n2)O(1)不稳定
直接插入排序O(n2)O(n)O(n2)O(1)稳定
希尔排序O(nlog2n)~O(n2)O(n1.3)O(n2)O(1)不稳定
堆排序O(nlog2n)O(nlog2n)O(nlog2n)O(1)不稳定
归并排序O(nlog2n)O(nlog2n)O(nlog2n)O(n)稳定
快速排序O(nlog2n)O(nlog2n)O(n2)O(log2n)~O(n)不稳定
两情若是久长时，又岂在朝朝暮暮
Copyright © 2024 xlc520