devbox
我家自动化
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

八大排序算法——（万字图文详解）_排序算法详细讲解

作者：我家自动化 | 2024-04-20 00:32:35

赞

踩

排序算法详细讲解

本篇文章是我对之前写过的八个排序算法的总结，感兴趣的小伙伴可以去我的八大排序算法专栏浏览，也可以点击下方标题跳转。

提示：本篇博客篇幅较长，建议小伙伴们查看目录，按需浏览

目录

正文

1 直接插入排序

2 希尔排序

3 直接选择排序

3.1 改进算法（双指针）

4 堆排序

5 冒泡排序

5.1 稍加优化

6 快速排序

6.1 方法一：挖坑法

6.2 方法二：左右指针法

6.3 方法三：前后指针法

6.4 方法四：非递归

6.5 优化

7 归并排序

7.1 非递归

8 计数排序

9 八大排序稳定性分析

9.1 什么是稳定性

9.2 直接插入排序

9.3 希尔排序

9.4 直接选择排序

9.5 堆排序

9.6 冒泡排序

9.7 快速排序

9.8 归并排序

9.9 计数排序

10 总结

11 参考代码

12 八大排序效率比较

13 结语

正文

本篇博客将对“直接插入排序”、“希尔排序”、“直接选择排序”、“堆排序”、“冒泡排序”、“快速排序”、“归并排序”、“计数排序”进行详细的解析（算法逻辑、具体实现过程、时间复杂度、稳定性），并附以图片帮助大家更好地理解算法逻辑以及实现每个排序的参考代码。

注：在本文中，均以升序排序进行讲解

1 直接插入排序

基本思想：

  • 直接插入排序是一种简单明了的插入排序法，其基本思想是：把待排序的数据按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有数据插入完为止。

  • 在现实生活中，我们玩扑克对牌进行排序就运用了这种思想。

整体插入思想：

统一使用升序

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

  • 如对数组{2, 5, 4, 6, 8, 7, 1}进行升序排序：

代码实现：

  • 我们假设数组中[0,end]的数据已经有序，要将nums[end + 1]这个元素插入到[0,end]中，使[0,end + 1]也有序

  • 因为可能要进行数据后移的操作，为防止nums[end + 1]被覆盖而无法得到其值，要事先用临时变量保存

  1.  int end;
  2.  int temp = nums[end + 1];

  • 运用插入排序的思想，将nums[end + 1]（即temp）从后往前依次与有序的元素进行比较，满足条件就插入

  1.  while (end >= 0)
  2.  {
  3.      /*
  4.          如果后面的数比前面的小，那就将前面的数后移
  5.          继续将后面的数与更前面的数（即更小的数）比较
  6.      */
  7.      if (temp < nums[end])
  8.      {
  9.          nums[end + 1] = nums[end];
  10.          end--;
  11.      }
  12.      /*
  13.          否则，如果后面的数比前面的大
  14.          那么满足升序条件，将temp插入到nums[end]的后面
  15.      */
  16.      else
  17.          nums[end + 1] = temp;
  18.  }

  • 但是，上面这段代码还是存在一个小小的bug，即如果我们要插入的元素temp比有序序列的第一个元素nums[0]还要小，那么执行完nums[end + 1] = nums[end];end--;这一操作后，end就等于-1了，而循环的条件是end >= 0，无法进入循环，end[0]这一位置也无法被赋值，因此，我们要进行改进：

  1.  while (end >= 0)
  2.  {
  3.      if (temp < nums[end])
  4.      {
  5.          nums[end + 1] = nums[end];
  6.          end--;
  7.      }
  8.      
  9.      /*
  10.          如果后面的数比前面的大
  11.          那么满足升序条件，直接退出循环
  12.      */
  13.      else
  14.          break;
  15.  }
  16.  ​
  17.  //将（end >= 0 && temp > nums[end]）和 （end == -1）这两种情况整合到一起
  18.  nums[end + 1] = temp;

  • 设待排序数组有numsSize个元素，因此要使数组有序，就要用一层for循环来分别判断数组的每个值是否处于正确的位置。

  1.  //为防止数组越界，i的最大值为numsSize - 2
  2.  for (int i = 0; i < numsSize - 1; i++)
  3.  {
  4.      int end = i;
  5.      int temp = nums[end + 1];
  6.      …………
  7.  }

动图演示：

实现代码：

  1.  void sort(int* nums, int numsSize)
  2.  {
  3.      //为防止数组越界，i的最大值为numsSize - 2
  4.      for (int i = 0; i < numsSize - 1; i++)
  5.      {
  6.          /*
  7.              假设[0,end]已经有序
  8.              要将nums[end + 1]这个元素插入到[0,end]中，使[0,end + 1]也有序
  9.          */
  10.          int end = i;
  11.          int temp = nums[end + 1];   //因为可能要进行数据后移的操作，为防止nums[end + 1]被覆盖而无法得到其值，要事先用临时变量保存  
  12.          
  13.          while (end >= 0)
  14.          {
  15.              if (temp < nums[end])
  16.              {
  17.                  nums[end + 1] = nums[end];
  18.                  end--;
  19.              }
  20.  ​
  21.              /*
  22.                  如果后面的数比前面的大
  23.                  那么满足升序条件，直接退出循环
  24.              */
  25.              else
  26.                  break;
  27.          }
  28.  ​
  29.          //将（end >= 0 && temp > nums[end]）和 （end == -1）这两种情况整合到一起
  30.          nums[end + 1] = temp;
  31.      }
  32.  }

时间复杂度：

统一为升序排序

  • 最好的情况：最好的情况就是数组已经升序有序，只有最外面一层for循环遍历一次数组，里面的while循环每一次都是直接退出，因此最好的情况时间复杂度为O(N)

  • 最坏的情况：最坏的情况就是数组是降序排序，里面while循环的时间复杂度为O(N)，因此最坏情况下，时间复杂度为O(N^2)

  • 综上，直接插入法的时间复杂度为O(N^2)

2 希尔排序

注1：本篇是基于对直接插入排序法的拓展，如果对直接插入法不了解，建议先看看直接插入排序

注2：本篇统一采用升序排序

基本思想：

  • 希尔排序其实是直接插入排序的改进。

  • 其基本思想是：先选定一个整数gap，把待排序文件中所有记录分成数组，所有距离为gap的记录分在同一组内，并对每一组内的记录进行排序。然后缩小gap，重复上述步骤，当gap == 1时，所有记录在统一组内已经排好序。

整体插入思想：

  • 在直接插入排序中，我们知道最坏的情况是待排序列降序逆序的情况，如序列：8,7,6,5,4,3,2,1，这时时间复杂度为O(N2)，显然效率不高

  • 而希尔排序的思想，就是先对待排序列进行预排序，使待排序列接近有序。我们知道，当待排序列接近有序时，直接插入排序法的时间复杂度接近O(N)，效率很高，因此预排序过后，就使用直接插入排序法，从而提高了效率。

预排序：

  • 预排序实际上也是直接插入排序，但是是将待排序列分成数组来排

  • 根据基本思想，规定间隔为gap的数为一组

  • 我们以数组{9,8,7,6,5,4,3,2,1}，gap = 3为例：

    • 每gap为一组：

    • 对第一组排序：

    • 对第二组排序：

    • 对第三组排序：

  • 这时相较于最开始，待排序列更加接近于有序，此时我们不断缩小gap，不断预排序，直到最后gap == 1时最后使用一次直接插入排序（gap == 1时的直接插入排序实际上就是最原始的直接插入排序），使待排序列有序。

  • 又例如：

结论：

  • 希尔排序实际上就是多组间隔为gap的预排序，gap由大到小

  • gap越大，大的数能越快到后面，小的数能越快到前面

  • gap越大，预排序之后待排序列越不接近于有序

  • gap越小，预排序之后待排序列越接近于有序

  • 当gap == 1时，预排序实际上就是对整个序列进行直接插入排序，排完后序列即有序

  • 因此，最后一次预排序，gap必须为1.

代码实现：

  • 对每间隔gap的一组数据进行排序，本质上就是直接插入排序，故不作过多讲解

  1.  int end;
  2.  int temp = nums[end + gap];
  3.  while (end >= 0)
  4.  {
  5.      if (temp < nums[end])
  6.      {
  7.          nums[end + gap] = nums[end];
  8.          end -= gap;
  9.      }
  10.      else
  11.          break;
  12.  }
  13.  nums[end + gap] = temp;

  • 对多组间隔为gap的数据进行预排序

    • 以这张图为例：

    • 我们上面的步骤只是将间隔为pap的一组数据进行了排序，但待排序列不止一组间隔为gap的数据，因此我们要做到将所有间隔为gap的每组数据都进行排序。

    • 怎么实现呢？可能最容易想到的是分别将每组间隔为gap的数据进行排序，例如上面分别对第一组，第二组，第三组排序，但是这样做效率不高，且操作复杂。因此我们要换一种想法，即把间隔为gap的数据同时排序。

    • 如图：

  1.  for (int i = 0; i < numsSize - gap; i++)
  2.  {
  3.      int end = i;
  4.      int temp = nums[end + gap];
  5.      while (end >= 0)
  6.      {
  7.          if (temp < nums[end])
  8.          {
  9.              nums[end + gap] = nums[end];
  10.              end -= gap;
  11.          }
  12.          else
  13.              break;
  14.      }
  15.      nums[end + gap] = temp;
  16.  }

  • 最后还要不断缩小gap的值，直到gap == 1

  1.  int gap = numsSize;
  2.  while (gap > 1)
  3.  {
  4.      gap /= 2;   //不断缩小gap
  5.      /*
  6.          也可以写成 gap = gap / 3 + 1;
  7.          总之，必须要保证最后一次gap == 1
  8.      */
  9.  ​
  10.      for (int i = 0; i < numsSize - gap; i++)
  11.      {
  12.          int end = i;
  13.          int temp = nums[end + gap];
  14.          while (end >= 0)
  15.          {
  16.              if (temp < nums[end])
  17.              {
  18.                  nums[end + gap] = nums[end];
  19.                  end -= gap;
  20.              }
  21.              else
  22.                  break;
  23.          }
  24.          nums[end + gap] = temp;
  25.      }
  26.  }

动图演示：

实现代码：

  1.  void ShellSort(int* nums, int numsSize)
  2.  {
  3.      int gap = numsSize;
  4.      while (gap > 1)
  5.      {
  6.          gap /= 2;
  7.          for (int i = 0; i < numsSize - gap; i++)
  8.          {
  9.              int end = i;
  10.              int temp = nums[end + gap];
  11.              while (end >= 0)
  12.              {
  13.                  if (temp < nums[end])
  14.                  {
  15.                      nums[end + gap] = nums[end];
  16.                      end -= gap;
  17.                  }
  18.                  else
  19.                      break;
  20.              }
  21.              nums[end + gap] = temp;
  22.          }
  23.      }
  24.  }

直接插入排序与希尔排序的效率比较：

  • 看到希尔排序有三层循环，可能有小伙伴会疑惑希尔排序为什么会比直接插入排序快，这里我们先上测试代码，直观的来感受这两个排序算法之间的差距：

测试代码：

  1.  #include<stdio.h>
  2.  #include<stdlib.h>
  3.  #include<time.h>
  4.  ​
  5.  //直接插入排序
  6.  void InsertSort(int* nums, int numsSize)
  7.  {
  8.      for (int i = 0; i < numsSize - 1; i++)
  9.      {
  10.          int end = i;
  11.          int temp = nums[end + 1];
  12.          while (end >= 0)
  13.          {
  14.              if (temp < nums[end])
  15.              {
  16.                  nums[end + 1] = nums[end];
  17.                  end--;
  18.              }
  19.              else
  20.                  break;
  21.          }
  22.          nums[end + 1] = temp;
  23.      }
  24.  }
  25.  ​
  26.  //希尔排序
  27.  void ShellSort(int* nums, int numsSize)
  28.  {
  29.      int gap = numsSize;
  30.      while (gap > 1)
  31.      {
  32.          gap /= 2;
  33.          for (int i = 0; i < numsSize - gap; i++)
  34.          {
  35.              int end = i;
  36.              int temp = nums[end + gap];
  37.              while (end >= 0)
  38.              {
  39.                  if (temp < nums[end])
  40.                  {
  41.                      nums[end + gap] = nums[end];
  42.                      end -= gap;
  43.                  }
  44.                  else
  45.                      break;
  46.              }
  47.              nums[end + gap] = temp;
  48.          }
  49.      }
  50.  }
  51.  ​
  52.  int main()
  53.  {
  54.      srand((unsigned int)time(NULL));
  55.  ​
  56.     //创建两个大小为N的数组
  57.      const int N = 100000;
  58.      int* a1 = (int*)malloc(sizeof(int) * N);
  59.      int* a2 = (int*)malloc(sizeof(int) * N);
  60.  ​
  61.     //为数组赋随机值
  62.      for (int i = 0; i < N; i++)
  63.      {
  64.          a1[i] = rand();
  65.          a2[i] = a1[i];
  66.      }
  67.  ​
  68.     /*
  69.      clock()函数可以记录当前时间
  70.      begin和end的差即排序算法运行的时间
  71.      注：时间的单位为毫秒(ms)
  72.     */
  73.      int beginl = clock();
  74.      InsertSort(a1, N);
  75.      int end1 = clock();
  76.  ​
  77.      int begin2 = clock();
  78.      ShellSort(a2, N);
  79.      int end2 = clock();
  80.  ​
  81.      printf("InsertSort:%d\n", end1 - beginl);
  82.      printf("ShellSort:%d\n", end2 - begin2);
  83.  ​
  84.     //释放内存
  85.      free(a1);
  86.      free(a2);
  87.  ​
  88.      return 0;
  89.  ​
  90.  }

  • 测试结果：

  • 我们可以看到，当数据个数为十万个时，直接插入排序所需要的时间是的希尔排序的100多倍

  • 当数据个数为一百万个时，直接插入排序所需要的时间时希尔排序的2000倍、

  • 可见，数据越多，希尔排序的优势就越明显，节省点时间就越多

时间复杂度：

  • 从上面的测试中，我们直观的感受到了相较于直接插入排序，希尔排序的优越性，那么具体的希尔排序的时间复杂度为多少呢？

  • 我们先来看最外层的循环：

  1.  int gap = numsSize;
  2.  while (gap > 1)
  3.  {
  4.      gap /= 2;
  5.      …………
  6.  }

  • 设最外层循环运行了x次，那么2x = numsSize，x = log2N，即最外层的时间复杂度为log2N

  • 再看里面两层循环：

  1.  for (int i = 0; i < numsSize - gap; i++)
  2.  {
  3.      int end = i;
  4.      int temp = nums[end + gap];
  5.      while (end >= 0)
  6.      {
  7.          if (temp < nums[end])
  8.          {
  9.              nums[end + gap] = nums[end];
  10.              end -= gap;
  11.          }
  12.          else
  13.              break;
  14.      }
  15.      nums[end + gap] = temp;
  16.  }

  • 当gap很大时，尽管有两层循环，但数据之间跳跃的很大，需要排序的次数很少，因此时间复杂度为O(N)，例如这种情况：

  • 当gap很小时，尽管有两层循环，但此时数据已经接近有序，需要排序的次数也很少，因此时间复杂度也为O(N)。

  • 综上，希尔排序的时间复杂度为O(NLogN)

  • 也可以认为时间复杂度为O(N^1.3)

3 直接选择排序

以升序排序为例

算法步骤：

方法一：直接交换数组元素

  • 将第一个元素与其他元素进行比较，若其他元素小于第一个元素，则交换位置，最后第一个元素为最小元素

  • 将剩余元素的第一个元素与其他元素进行比较，若其他元素小于第一个元素，则交换位置

  • 重复上述步骤，直到第（n-1）个元素比较完毕

方法二：利用数组下标间接交换数组元素

  • 将第一个元素的下标标记为min，将第一个元素与其他元素进行比较，若其他元素小于第一个元素，则令该元素的数组下标为min，一轮比较完后，若第一个元素的下标不等于min，则交换第一个元素与下标为min的元素的位置

  • 对剩下的元素重复上述步骤，直到没有元素需要交换位置

动图演示：

实现代码：

  1.  #include<stdio.h>
  2.  void WayOne(int *p,int num)     //利用直接交换数组元素，从小到大排列数组
  3.  {
  4.      int i,j,temp;
  5.      for(i=0;i<num-1;i++)        //需比较（数组元素-1）次
  6.          for(j=i+1;j<num;j++)
  7.              if(p[i]>p[j])
  8.              {
  9.                  temp=p[i];
  10.                  p[i]=p[j];
  11.                  p[j]=temp;
  12.              }
  13.      for(i=0;i<num;i++)
  14.          printf("%-5d",p[i]);
  15.  }
  16.  void WayTwo(int *p,int num)     //利用元素下标间接交换数组元素，从大到小排列数组
  17.  {
  18.      int i,j,temp,max;
  19.      for(i=0;i<num-1;i++)
  20.      {
  21.          max=i;          //设置标记
  22.          for(j=i+1;j<num;j++)
  23.              if(p[j]>p[max])
  24.                  max=j;
  25.          if(max!=i)
  26.          {
  27.              temp=p[max];
  28.              p[max]=p[i];
  29.              p[i]=temp;
  30.          }
  31.      }
  32.      for(i=0;i<num;i++)
  33.          printf("%-5d",p[i]);
  34.  }
  35.  int main()
  36.  {
  37.      int a[]={12,134,46,688,563,145,7357,26,24};
  38.      WayOne(a,sizeof(a)/sizeof(int));
  39.      printf("\n");
  40.      WayTwo(a,sizeof(a)/sizeof(int));
  41.      return 0;
  42.  }

3.1 改进算法（双指针）

具体步骤：

  • 上面的直接选择排序每一次只能选出一个数据，但是，我们可以用双指针的方法进行改进，做到每一次可以选出两个数据

  • 首先，我们令begin指向数组第一个元素，end指向数组最后一个元素

  • 然后，遍历[begin,end]这一块区域，同时保存最大值和最小值元素的下标max_index、min_index

  • 由于进行的是升序排序，begin位置应该放置最小值，end位置应该放置最大值，我们就可以利用下标来交换begin、min_index和end、max_index的数据

  • 缩小区域[begin,end]，重复上述步骤，直到不能满足条件begin < end

实现代码：

  1. void SelectSort(int* nums, int numsSize)
  2.  {
  3.      int begin = 0;
  4.      int end = numsSize - 1;
  5.      
  6.      while (begin < end)
  7.      {
  8.          int max_index = end;
  9.          int min_index = begin;
  10.          for (int i = begin; i <= end; i++)
  11.          {
  12.              //得到最小值的下标
  13.              if (nums[i] < nums[min_index])
  14.                  min_index = i;
  15.              
  16.              //得到最大值的下标
  17.              if (nums[i] > nums[max_index])
  18.                  max_index = i;
  19.          }
  20.          
  21.          //将最小值放到前面
  22.          Swap(&nums[begin], &nums[min_index]);
  23.          
  24.          //将最大值放到后面
  25.          Swap(&nums[end], &nums[max_index]);
  26.          
  27.          //缩小区间
  28.          begin++;
  29.          end--;
  30.      }
  31.  }

具体过程：

处理特殊情况：

  • 如果遍历完后存在这么一种情况：

  • 我们执行完第一次交换Swap(&nums[begin], &nums[min_index])后：

  • 再执行第二次交换Swap(&nums[end], &nums[max_index]):

  • 我们发现，最小值-1竟然被放到了最后，这显然是不对的，为什么会出现这样的情况呢？

  • 出现这种情况是因为最大值元素的下标刚好是begin，当我们执行第一次交换Swap(&nums[begin], &nums[min_index])后，begin（max_index）代表的值就是最小值，因此当我们执行第二次交换Swap(&nums[end], &nums[max_index])时，就会将最小值放到最后（即end的位置）

  • 为了避免这种情况，应该在第一次交换后进行一次判断，对max_index的位置进行修正

  1.  /*
  2.      如果 begin == max_index
  3.      那么第一次交换Swap(&nums[begin], &nums[min_index])后，min_index的值其实是最大值
  4.      因此，要将max_index的值修正为min_index
  5.  */
  6.  if (begin == max_index)
  7.      max_index = min_index;

实现代码：

  1. void Swap(int* num1, int* num2)
  2.  {
  3.      int temp = *num1;
  4.      *num1 = *num2;
  5.      *num2 = temp;
  6.  }
  7.  ​
  8.  void SelectSort(int* nums, int numsSize)
  9.  {
  10.      int begin = 0;
  11.      int end = numsSize - 1;
  12.      
  13.      while (begin < end)
  14.      {
  15.          int max_index = end;
  16.          int min_index = begin;
  17.         for (int i = begin; i <= end; i++)
  18.          {
  19.              //得到最小值的下标
  20.              if (nums[i] < nums[min_index])
  21.                  min_index = i;
  22.              
  23.              //得到最大值的下标
  24.              if (nums[i] > nums[max_index])
  25.                  max_index = i;
  26.          }
  27.          
  28.          //将最小值放到前面
  29.          Swap(&nums[begin], &nums[min_index]);
  30.          
  31.          //对max_index进行修正
  32.          if (begin == max_index)
  33.              max_index = min_index;
  34.          
  35.          //将最大值放到后面
  36.          Swap(&nums[end], &nums[max_index]);
  37.          
  38.          //缩小区间
  39.          begin++;
  40.          end--;
  41.      }
  42.  }

改进后和为改进的直接选择排序算法的比较：

  • 我们来看看这两个数对100000个数排序分别消耗了多少时间（其中SelectSort_One为为改进的直接选择排序，SelectSort_Two为改进了的直接选择排序）：

  •  可见相较于一次只选一个数，一次选两个数还是可以显著的提高排序效率。

时间复杂度：

  • 直接选择排序虽然容易理解，但可以说是效率最低的一个排序算法

  • 在为改进的直接选择排序中，我们要遍历数组的每个元素，同时还要将每个元素和其他未有序的元素一一比较，因此时间复杂度为O(N^2)

  • 在改进的直接选择排序中，最外层的while()循环的时间复杂度为O(N)，里面for循环的时间复杂度也是O(N)，因此整体的时间复杂度仍为O(N^2)

  • 综上，直接选择排序的时间复杂度为O(N^2)

4 堆排序

注：堆排序涉及到二叉树，对二叉树还不了解到小伙伴建议先看看数和二叉树

什么是堆：

  • 在学习堆排序之前，我们要先知道堆是什么

  • 堆的逻辑结构是一棵完全二叉树

  • 堆的物理结构是一个数组

  • 即我们可以将堆看成是一棵完全二叉树的顺序存储

父子节点的关系：

  • 我们可以通过数组的下标来确定父子节点的关系，结论如下

  • leftchild = parent * 2 + 1

  • rightchild = parent * 2 + 2

  • parent = (child - 1) / 2

对的两个特性：

  • 结构性：用数组表示的完全二叉树

  • 有序性：任意节点的关键值是其子树所有节点的最大值（或最小值）

    • ”最大堆(MaxHeap)“，也叫”大顶堆“：最大值，即每棵子树的根节点的值都大等于于其子节点的值

    • ”最小堆(MaxHeap)“，也叫”小顶堆“：最小值，即每棵子树的根节点的值都小于等于其子节点的值

  • 例如上图，是小顶堆

  • 又例如：(101, 88, 46, 70, 34, 39, 45, 58, 66, 10)是大堆

怎么堆排序：

  • 堆排序实际上也是一种选择排序，只是利用了堆来提高了效率

第一步——建堆：

  • 假设我们要对一个乱序数组进行堆排序，那么首先就要在这个数组的基础上建立大堆或小堆

  • 我们以建小堆为例：

  • 由于堆这一概念基于完全二叉树，因此我们先要将数组看成完全二叉树的形式，如对于数组{27,15,19,18,28,34,65,49,25,37}：

  • 接下来我们就采用向下调整算法来实现先建堆

  • 向下调整算法：

    • 使用前提：左右子树都是小堆

    • 步骤：从根节点开始，选出左右孩子值较小的那一个并跟父亲比较，如果小于，那么就交换父亲节点和较小值节点的值，然后继续向下调整，调到叶子节点或父亲小于较小值就终止

    • 具体过程如图所示：

向下调整算法代码实现：

  1.  void AdjustDown(int *nums, int numsSize, int root)
  2.  {
  3.      int parent = root;
  4.      int child = parent * 2 + 1;     //首先默认左右孩子的较小值是左孩子，然后再在循环里判断取值
  5.      while ( child < numsSize)
  6.      {
  7.          //如果右孩子小于左孩子，那么child取值为右孩子的下标
  8.          if (child + 1 < numsSize &&nums[child] > nums[child + 1])
  9.              child += 1;
  10.          //如果字节点的值小于父节点，那么就交换这两个值
  11.          if (nums[child] < nums[parent])
  12.          {
  13.              Swap(&nums[child], &nums[parent]);  //Swap需要自己实现
  14.              //继续向下调整
  15.              parent = child;
  16.              child = parent * 2 + 1;
  17.          }
  18.          //如果没有交换子节点和父节点，就说明这已经是一个小堆
  19.          else
  20.              break;
  21.      }
  22.  }

  • 如果是建大堆，则将代码改为：

  1.  void AdjustDown(int *nums, int numsSize, int root)
  2.  {
  3.      int parent = root;
  4.      int child = parent * 2 + 1;     //首先默认左右孩子的较小值是左孩子，然后再在循环里判断取值
  5.      while ( child < numsSize)
  6.      {
  7.          //如果右孩子大于左孩子，那么child取值为右孩子的下标
  8.          if (child + 1 < numsSize &&nums[child] < nums[child + 1])
  9.              child += 1;
  10.          //如果字节点的值大于父节点，那么就交换这两个值
  11.          if (nums[child] > nums[parent])
  12.          {
  13.              Swap(&nums[child], &nums[parent]);  //Swap需要自己实现
  14.              //继续向下调整
  15.              parent = child;
  16.              child = parent * 2 + 1;
  17.          }
  18.          //如果没有交换子节点和父节点，就说明这已经是一个小堆
  19.          else
  20.              break;
  21.      }
  22.  }

确保左右子树都是小堆：

  • 我们不可能保证，对于给定的任意一个数组，进行堆排序的向下调整算法时都能保证它的左右子树都是大堆或小堆

  • 因此在进行向下调整算法前我们还要先对数组进行调整，使其左右子树满足使用条件。那么如何实现？

  • 我们以数组{3,5,2,7,8,6,1,9,4,0}为例：

  • 要满足每个父节点的左右子树都是小堆，那么我们就可以采用分治思想，从最小、最后的一棵子树开始看，不断进行向下调整算法，从而可以做到每棵子树是小堆，即自下而上建堆

    • 有小伙伴可能会问怎么得到最后一棵子树的父节点呢？不知道小伙伴还是否记得左右孩子与父节点的关系式：leftchild = parent * 2 + 1、rightchild = parent * 2 + 2，我们知道最后一个叶子节点的下标是numsSize-1，那么最后一棵子树的父节点下标就是(numsSize - 2) / 2

建堆实现代码：

  • 注：此处建立的是小堆

  1.  void HeapBuild(int* nums, int numsSize)
  2.  {
  3.      for (int i = (numsSize - 2) / 2; i >= 0; i--)
  4.          AdjustDown(nums, numsSize, i);
  5.  }

第二步——实现排序

  • 假设我们要实现对数组{3,5,2,7,8,6,1,9,4,0}的升序排序，那么首先我们就要思考一个问题：是用大堆还是用小堆？

  • 假设我们使用的是小堆：那么建堆后的数组是这样的：0 3 1 4 5 6 2 9 7 8，把它看成完全二叉树形式：

  • 由于是要实现升序排序，且用的是小堆，因此堆顶元素就是最小值，在第二次建小堆得到次小值时就要将第一个数“0”忽略，即对数组(3 1 4 5 6 2 9 7 8)建小堆，但是如果这样，数据之间的关系就会被打乱，在使用向下调整算法时就不能满足所有子树都是小堆的情况，如图：

  • 因此如果要用小堆来实现升序排序，就先要保证其左右子树都是小堆，效率不高

  • 而如果用的是大堆来排序，那第一次建堆后是这样的：

  • 因为是要进行升序排序且用的是大堆，因此，堆顶元素就是最大值，我们可以将堆顶元素和最后一个元素交换位置，这样数组中最大的元素就到了数组最后的位置，之后也只需要对前numsSize-1个数据处理即可，如图：

  • 从上图中我们可以看到，根节点“0”的左右子树仍然为大堆，可见利用大堆来进行升序排序不会打乱数据之间的关系，这样就可以直接用向下调整算法来再建大堆，重复上述步骤，最终得到升序序列。

动图演示：

实现升序排序代码：

  1.  //建大堆
  2.  void AdjustDown(int *nums, int numsSize, int root)
  3.  {
  4.      int parent = root;
  5.      int child = parent * 2 + 1;     //首先默认左右孩子的较小值是左孩子，然后再在循环里判断取值
  6.      while ( child < numsSize)
  7.      {
  8.          //如果右孩子大于左孩子，那么child取值为右孩子的下标
  9.          if (child + 1 < numsSize &&nums[child] < nums[child + 1])
  10.              child += 1;
  11.          //如果字节点的值大于父节点，那么就交换这两个值
  12.          if (nums[child] > nums[parent])
  13.          {
  14.              Swap(&nums[child], &nums[parent]);  //Swap需要自己实现
  15.              //继续向下调整
  16.              parent = child;
  17.              child = parent * 2 + 1;
  18.          }
  19.          //如果没有交换子节点和父节点，就说明这已经是一个小堆
  20.          else
  21.              break;
  22.      }
  23.  }
  24.  void HeapSort(int* nums, int numsSize)
  25.  {
  26.      //建堆
  27.      for (int i = (numsSize - 2) / 2; i >= 0; i--)
  28.          AdjustDown(nums, numsSize, i);
  29.      //排序
  30.      int end = numsSize - 1;
  31.      while (end > 0)
  32.      {
  33.          /*
  34.              不断交换堆顶和最后一个元素的值
  35.              交换完后忽略最后一个元素，重新建大堆
  36.              继续交换
  37.              直到只剩下一个元素
  38.          */
  39.          Swap(&nums[end], &nums[0]);
  40.          AdjustDown(nums, end, 0);
  41.          end--;
  42.      }
  43.  }

  • 同理，如果要实现降序排序，只需要将建大堆改为建小堆即可

时间复杂度：

  • 由于论证过程过于复杂，下面直接给出结论

  • 向下调整算法AdjustDown()的时间复杂度为O(logN)

  • 自下而上建堆的时间复杂度为O(N)

  • 建堆后排序的时间复杂度为O(NlogN)

  • 因此整个堆排序的时间复杂度为O(NlogN)

回顾：

  • 我们再来看看为什么实现升序排序为什么要用大堆而不是用小堆：

  • 我们前面提到，如果是小堆，那么将第一个数（小堆堆顶元素）排除后，数据次序就会被打乱，要建小堆首先就需要保证其左右子树都是小堆，而这一过程的时间复杂度是O(N)，由于要对N个元素排序，那么这一过程就要进行N次，因此整体的时间复杂度为O(N2)

  • 如果用的是大堆，那么将第一个数（大堆堆顶元素）和最后一个数交换后，将最后一个数排除在外，数据的次序不会被打乱，因此我们可以直接以第一个数为根，它的左右子树直接就是大堆，可以直接进行向下调整算法，时间复杂度为O(logN)，因为有N个数，因此整体的时间复杂度就是O(Nlog2N)

5 冒泡排序

算法步骤：

以升序排序为例：

  • 比较相邻元素，如果前面的比后面的元素大，则两元素交换位置

  • 对每一对相邻元素进行比较，大的放后，这样最后的元素将是最大的元素

  • 对越来越少的混乱元素重复上述步骤（最后的元素已经有序，不需比较），直到没有元素需要交换位置

动图演示：

实现代码：

  1.  void BubbleSort(int* nums, int numsSize)
  2.  {
  3.      for (int i = 0; i < numsSize - 1; i++)
  4.      {
  5.          for (int j = 0; j < numsSize - 1 - i; j++)
  6.          {
  7.              if (nums[j] > nums[j + 1])
  8.              {
  9.                  Swap(&nums[j], &nums[j + 1]);   //Swap()函数需要自己实现
  10.              }
  11.          }
  12.      }
  13.  }
 

5.1 稍加优化
 

  •  
    如果在一趟遍历中未发生交换，就可以说明数组已经有序
     
  •  
    因此我们可以设计一个标记flag，每次外层循环开始时都初始化为1，若内层循环发生了交换就将其改为0
     
  •  
    因此如果内层循环结束后flag仍为1，就说明这一次遍历未发生交换，即数组已经有序
     
 

优化后的代码：
 

  1. void BubbleSort(int* nums, int numsSize)
  2.  {
  3.      for (int i = 0; i < numsSize - 1; i++)
  4.      {
  5.          int flag = 1;
  6.          for (int j = 0; j < numsSize - 1 - i; j++)
  7.          {
  8.              if (nums[j] > nums[j + 1])
  9.              {
  10.                  Swap(&nums[j], &nums[j + 1]);
  11.                  flag = 0;
  12.              }
  13.          }
  14.          if (flag)
  15.              break;
  16.      }
  17.  }
 

时间复杂度：
 

  •  
    易得冒泡排序的时间复杂度为O(N^2)
     
 

 

6 快速排序
 

以升序为例
 

何为快速排序：
 

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

 

 

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

6.1 方法一：挖坑法
 

挖坑法顾名思义，就是在待排数组的某一特定位置“挖坑”，然后用另外的元素填坑，从而达到将区间按照基准值划分为左右两半部分的目的
 

实现的基本思想：
 

第一步——处理第一个数：
 

  •  
    由于现在还没有数据处在正确的位置，因此排序区间是整个数组的长度
     
  •  
    可以将待排数组的第一个数（最左边的数）作为基准值key，同时将这个位置设为坑pivot
     
  •  
    设区间最左边的下标为left，最右边的下标为right，此时坑的位置即最左边left
     
 

  1.  int key = nums[0];  //基准值
  2.  int pivot = 0;      //坑的位置
  3.  int left = 0;       //区间最左边
  4.  int right = numsSize - 1;   //区间最右边
 

  •  
    由于是升序排序，要做到基准值key左边的元素全小于key，右边的元素全大于key。而坑pivot现在在左边，因此我们要利用右边的right，通过对其的移动找到小于key的数，并将这个数“挖走”，并填入坑pivot中，此时，被挖走的位置就成了新的坑
     
 

  1. //right不断向左移动，找到小于key的数
  2.  while (left < right && nums[right] >= key)
  3.      right--;
  4.  //将满足条件的数“挖走”，并填入坑pivot中
  5.  nums[pivot] = nums[right];
  6.  //被挖走数字的区域变成新的坑
  7.  pivot = right;
 

  •  
    这样坑pivot就到了右边，右边放的应该是大于基准值key的数，因此我们就要通过移动left来找到小于key的数，将其挖走并填入坑pivot中，同样，被挖走的位置也成了新的坑
     
 

  1. //left不断向右移动，找到大于key的数
  2.  while (begin < end && nums[begin] <= key)
  3.      begin++;
  4.  //将满足条件的数“挖走”，并填入坑pivot中
  5.  nums[pivot] = nums[begin];
  6.  //被挖走数字的区域变成新的坑
  7.  pivot = begin;
 

  •  
    通过循环，不断移动left和right，直到不能满足条件left < right，此时第一个数就被放到正确的位置了。
     
 

放置第一个数的具体过程：
 

我们以数组{5,8,2,9,1,3,7,4,6}为例：
 

 

放置第一个数的实现代码：
 

  1.  void QuickSort(int* nums, int numsSize)
  2.  {
  3.      int key = nums[0];  //基准值
  4.      int pivot = 0;      //坑的位置
  5.      int left = 0;       //区间最左边
  6.      int right = numsSize - 1;   //区间最右边
  7.      while (begin < end)
  8.      {
  9.          //right不断向左移动，找到小于key的数
  10.          while (left < right && nums[right] >= key)
  11.              right--;
  12.          //将满足条件的数“挖走”，并填入坑pivot中
  13.          nums[pivot] = nums[right];
  14.          //被挖走数字的区域变成新的坑
  15.          pivot = right;
  16.          
  17.          //left不断向右移动，找到大于key的数
  18.          while (begin < end && nums[begin] <= key)
  19.              begin++;
  20.          //将满足条件的数“挖走”，并填入坑pivot中
  21.          nums[pivot] = nums[begin];
  22.          //被挖走数字的区域变成新的坑
  23.          pivot = begin;
  24.      }
  25.      //将基准值填入最后坑的位置
  26.      nums[pivot] = key;
  27.  }
 

第二步——处理所有数：
 

  •  
    我们能够将一个数放在正确的位置，那么自然其他的数我们也可以用类似的方法来处理
     
  •  
    这里我们利用分治思想：分而治之。大问题分成类似的子问题，子问题再分成子问题……直到子问题不能再分割。
     
  •  
    处理完第一个数后，整个待排序列已经被分割成了两个子序列：[0,pivot - 1]和[pivot + 1, right]，我们可以利用同样的办法将个子区间继续分割，这样越来越多的元素到了正确的位置，直到每个区间的长度为1或0就可以表明待排序列以已经有序
     
  •  
    我们用递归来解决：
     
 

实现代码：
 

  1. void QuickSort(int* nums, int begin, int end)
  2.  {
  3.      //如果区间长度为1或0，则表示只有一个数，直接退出
  4.      if (begin >= end)
  5.          return;
  6.      
  7.      int key = nums[begin];  //基准值
  8.      int pivot = begin;      //坑的位置
  9.      int left = begin;       //区间最左边
  10.      int right = end;    //区间最右边
  11.      
  12.      while (left < right)
  13.      {
  14.          //right不断向左移动，找到小于key的数
  15.          while (left < right && nums[right] >= key)
  16.              right--;
  17.          //将满足条件的数“挖走”，并填入坑pivot中
  18.          nums[pivot] = nums[right];
  19.          //被挖走数字的区域变成新的坑
  20.          pivot = right;
  21.  ​
  22.          //left不断向右移动，找到大于key的数
  23.          while (left < right && nums[left] <= key)
  24.              left++;
  25.          //将满足条件的数“挖走”，并填入坑pivot中
  26.          nums[pivot] = nums[left];
  27.          //被挖走数字的区域变成新的坑
  28.          pivot = left;
  29.      }
  30.  ​
  31.      //将基准值填入最后坑的位置
  32.      nums[pivot] = key;
  33.  ​
  34.      //递归处理子区间
  35.      QuickSort(nums, begin, pivot - 1);
  36.      QuickSort(nums, pivot + 1, end);
  37.  }
 

6.2 方法二：左右指针法
 

实现的基本思想：
 

  •  
    左右指针法其实和挖坑法的思想十分类似，同样是先确定一个基准值key，然后通过左边的left找大于key的数和右边的right找小于key的数，然后进行一定的操作，从而达到有序
     
  •  
    不同点在于：左右指针法不会挖坑，而是在在右边的right找到小于key的数后，直接让左边的left找大于key的数，然后交换这两个值
     
    1.  //找到小于基准值的数
    2.  while (left < right && nums[right] >= key)
    3.      right--;
    4.  //找到大于基准值的数
    5.  while (left < right && nums[left] <= key)
    6.      left++;
    7.  //交换这两个数
    8.  Swap(&nums[right], &nums[left]);
     
  •  
    同样的，不断循环，直到不能满足条件left < right结束，最后再交换基准值和left、right相遇位置的数。
     
    1.  int key = nums[begin];  //基准值
    2.  int left = begin;
    3.  int right = end;
    4.  while (left < right)
    5.  {
    6.      //找到小于基准值的数
    7.      while (left < right && nums[right] >= key)
    8.          right--;
    9.      //找到大于基准值的数
    10.      while (left < right && nums[left] <= key)
    11.          left++;
    12.      //交换这两个数
    13.      Swap(&nums[right], &nums[left]);
    14.  }
    15.  //交换相遇值和基准值
    16.  Swap(&nums[begin], &nums[left]);
     
 

 

一趟循环的具体过程：
 

 

 

  •  
    和挖坑法一样，知道处理一个数，我们就可以用递归的方法来对其余的数进行处理
     
 

整体实现代码：
 

  1. void QuickSort(int* nums, int begin, int end)
  2.  {
  3.      if (begin >= end)
  4.          return;
  5.      
  6.      int key = nums[begin];  //基准值
  7.      int left = begin;
  8.      int right = end;
  9.      
  10.      while (left < right)
  11.      {
  12.          //找到小于基准值的数
  13.          while (left < right && nums[right] >= key)
  14.              right--;
  15.          //找到大于基准值的数
  16.          while (left < right && nums[left] <= key)
  17.              left++;
  18.          //交换这两个数
  19.          Swap(&nums[right], &nums[left]);
  20.      }
  21.      //交换相遇值和基准值
  22.      Swap(&nums[begin], &nums[left]);
  23.  ​
  24.      QuickSort(nums, begin, left - 1);
  25.      QuickSort(nums, left + 1, end);
  26.  }
 

6.3 方法三：前后指针法
 

实现的基本思想：
 

  •  
    前后指针法和前面两种方法不同，这里要定义指针prev指向待排区域的起始位置，指针cur指向prev的后一个位置
     
    1.  int prev = begin;
    2.  int cur = begin + 1;
     
  •  
    令cur不断向右移动遍历待排区域，当碰到小于基准值key的数就停止，同时让prev也向右移动一个（即prev++），交换prev和cur位置的数据
     
  •  
    不断循环，直到cur遍历完整个数组
     
    1.  while (cur <= end)
    2.  {
    3.      if (nums[cur] < key)
    4.      {
    5.          prev++;
    6.          Swap(&nums[cur], &nums[prev]);
    7.      }
    8.      cur++;
    9.  }
     
  •  
    最后，再将基准值放到正确的位置，即将最后prev和begin位置的元素交换位置
     
     Swap(&nums[begin], &nums[prev]);
     
  •  
    可能有小伙伴会疑惑，为什么当nums[cur] < key时，将prev++，再交换cur和prev位置的数据，就可以将小的数据放在前面，大的数据放在后面，我通过下面这张图来解释：
     
 

 

 

一趟循环的具体过程：
 

 

改进：
 

  •  
    如果待排数组是这样的：
     
 

 

 

  •  
    那么会出现这样的情况：
     
 

 

 

  •  
    因此我们可以对if判断多加一个条件：++prev != cur，这样就可以避免对一个数字进行交换了
     
 

实现代码：
 

  1. void QuickSort(int* nums, int begin, int end)
  2.  {
  3.      if (begin >= end)
  4.          return;
  5.  ​
  6.      int key = nums[begin];
  7.      int prev = begin;
  8.      int cur = begin + 1;
  9.      
  10.      while (cur <= end)
  11.      {
  12.          
  13.          if (nums[cur] < key && ++prev != cur)
  14.              Swap(&nums[cur], &nums[prev]);
  15.          
  16.          cur++;
  17.      }
  18.      Swap(&nums[begin], &nums[prev]);
  19.  ​
  20.      //对余下数字进行递归整理
  21.      QuickSort(nums, begin, prev - 1);
  22.      QuickSort(nums, prev + 1, end);
  23.  }
 

6.4 方法四：非递归
 

  •  
    我们知道，递归有一个致命的缺陷，即如果递归的深度太深，就可能会发生栈溢出，从而导致程序无法正常运行
     
  •  
    因此我们有必要掌握快速排序的非递归算法
     
  •  
    通过上面的递归讲解，我们知道，快速排序实际上就是不断重复将一个数放到正确位置这一过程，在这个过程中，待排序列会被分割成数个长度已知的子序列，因此可以用分治思想和递归来解决
     
  •  
    而要利用非递归来解决快速排序，我们可以利用数据结构中的栈，来进行模拟递归。
     
 

实现的基本思路：
 

  •  
    由于C语言的局限性，我们要用到栈，当然就要先创造一个栈，并实现有关其的基本操作。这里不赘述，如有疑问，可以去看看栈的相关操作
     
  •  
    在递归解法中，我们是对不断细分的子区间进行数据的整理，同样的，在非递归解法中，我们也需要利用这些不断细分的子区间来进行排序，而要能够像递归一样利用这些子区间，就需要用栈来对这些子区间的左右端的下标进行存储，为了方便讲解，我们先来看看具体的过程展示：
     
     
 

具体做法：
 

  •  
    假设我们要对长度为numsSize的数组进行排序
     
  •  
    先将数组两端的下标入栈
     
  •  
    注意： 注意先后顺序由于栈先入后出的特性应该先入后面的，再入前面的
     
 

  1.  StackPush(st, numsSize - 1);
  2.  StackPush(st, 0);
 

  •  
    进入循环，循环进行的条件为栈不能为空
     
  •  
    取出栈顶的两个元素，作为待排区间的左右端
     
  •  
    我们可以用挖坑法、前后指针法、左右指针法这三种方法对这一段区间进行一趟排序（即得到一个数正确的位置），同时得到这个正确位置的下标
     
  •  
    这样，这个正确位置就将待排序列分割为了两个子序列
     
  •  
    如果左边的子序列长度大于一，那么就将这个子序列的左右端入栈，对右序列进行相同的处理
     
  •  
    重复上述步骤，直到栈空
     
 

实现代码：
 

  1.  //挖坑法的一趟排序（即将一个数放在正确位置）
  2.  int PartSort(int* nums, int begin, int end)
  3.  {
  4.      int key = nums[begin];  //基准值
  5.      int pivot = begin;      //坑的位置
  6.      int left = begin;       //区间最左边
  7.      int right = end;    //区间最右边
  8.      while (left < right)
  9.      {
  10.          //right不断向左移动，找到小于key的数
  11.          while (left < right && nums[right] >= key)
  12.              right--;
  13.          //将满足条件的数“挖走”，并填入坑pivot中
  14.          nums[pivot] = nums[right];
  15.          //被挖走数字的区域变成新的坑
  16.          pivot = right;
  17.  ​
  18.          //left不断向右移动，找到大于key的数
  19.          while (left < right && nums[left] <= key)
  20.              left++;
  21.          //将满足条件的数“挖走”，并填入坑pivot中
  22.          nums[pivot] = nums[left];
  23.          //被挖走数字的区域变成新的坑
  24.          pivot = left;
  25.      }
  26.  ​
  27.      //将基准值填入最后坑的位置
  28.      nums[pivot] = key;
  29.  ​
  30.      //返回正确位置的下标
  31.      return pivot;
  32.  }
  33.  ​
  34.  void QuickSort(int* nums, int numsSize)
  35.  {
  36.      ST* st = (ST*)malloc(sizeof(ST));
  37.      
  38.      StackInit(st);  //初始化栈
  39.      
  40.      //先将待排序列的左右端点入栈
  41.      StackPush(st, numsSize - 1);
  42.      StackPush(st, 0);
  43.      
  44.      //当栈不为空进行循环
  45.      while (!StackEmpty(st))
  46.      {
  47.          //出栈，得到序列区间
  48.          int begin = StackFront(st);
  49.          StackPop(st);
  50.          int end = StackFront(st);
  51.          StackPop(st);
  52.          
  53.          //进行一趟排序，得到一个数的正确位置
  54.          //这一位置将待排序列分割为两个子序列
  55.          int key_index = PartSort(nums, begin, end);
  56.          
  57.          //如果右边的子序列长度大于一，那么将左右端点入栈
  58.          if (end - key_index > 0)
  59.          {
  60.              StackPush(st, end);
  61.              StackPush(st, key_index + 1);
  62.          }
  63.          
  64.          //如果左边的子序列长度大于一，那么将左右端点入栈
  65.          if (key_index - begin > 0)
  66.          {
  67.              StackPush(st, key_index - 1);
  68.              StackPush(st, begin);
  69.          }
  70.          
  71.      }
  72.  }
 

时间复杂度：
 

由于四种方法的思想有共通之处，故拿挖坑法为例
 

  •  
    我们先看其一趟排序：
     
    1.  //挖坑法的一趟排序（即将一个数放在正确位置）
    2.  int PartSort(int* nums, int begin, int end)
    3.  {
    4.      int key = nums[begin];  //基准值
    5.      int pivot = begin;      //坑的位置
    6.      int left = begin;       //区间最左边
    7.      int right = end;    //区间最右边
    8.      while (left < right)
    9.      {
    10.          //right不断向左移动，找到小于key的数
    11.          while (left < right && nums[right] >= key)
    12.              right--;
    13.          //将满足条件的数“挖走”，并填入坑pivot中
    14.          nums[pivot] = nums[right];
    15.          //被挖走数字的区域变成新的坑
    16.          pivot = right;
    17.  ​
    18.          //left不断向右移动，找到大于key的数
    19.          while (left < right && nums[left] <= key)
    20.              left++;
    21.          //将满足条件的数“挖走”，并填入坑pivot中
    22.          nums[pivot] = nums[left];
    23.          //被挖走数字的区域变成新的坑
    24.          pivot = left;
    25.      }
    26.  ​
    27.      //将基准值填入最后坑的位置
    28.      nums[pivot] = key;
    29.  ​
    30.      //返回正确位置的下标
    31.      return pivot;
    32.  }
     
  •  
    实际上就是left，right两个指针分别从左右遍历一次待排区间，时间复杂度为O(N)
     
  •  
    接下来，就是对这一过程进行不断递归，直到待排区间被分割为一个数，我们可以将这个分割过程看成是一棵满二叉树的情况：
     
 

 

  •  
    因此，递归的时间复杂度就是O(logN)
     
  •  
    综上，快速排序的时间复杂度为O(NlogN)
     
 

6.5 优化
 

处理最坏情况（以挖坑法为例）：
 

  •  
    先下结论：对于快速排序，最坏情况就是当数组为有序时（无论是正序还是逆序）
     
     
  •  
    为了处理类似的情况，我们就要对基准值的取值进行改变，我们一般采用三数取中的方法来进行对key的取值
     
  •  
    三数取中：比较待排区间两端点和中间的数，选择不大不小的那一个，和左端点的值交换，再将左端点的值作为基准值key
     
 

三数去中实现代码：
 

  1.  int GetMid(int* nums, int left, int right)
  2.  {
  3.      int mid = (right - left) / 2 + left;
  4.      if (nums[left] <= nums[mid])
  5.      {
  6.          if (nums[right] > nums[mid])
  7.              return mid;
  8.          else if (nums[right] > nums[left])
  9.              return right;
  10.          else
  11.              return left;
  12.      }
  13.      else    //nums[left] > nums[mid]
  14.      {
  15.          if (nums[right] > nums[left])
  16.              return left;
  17.          else if (nums[right] > nums[mid])
  18.              return right;
  19.          else
  20.              return mid;
  21.      }
  22.  }
 

改善后的代码：
 

  1.  void QuickSort(int* nums, int begin, int end)
  2.  {
  3.      if (begin >= end)
  4.          return;
  5.  ​
  6.      /*
  7.          为了不改变后序代码的逻辑
  8.          三数取中后，应交换中间数和开头数
  9.      */
  10.      int index = GetMid(nums, begin, end);
  11.      Swap(&nums[index], &nums[begin]);
  12.  ​
  13.      int key = nums[begin];  //基准值
  14.      int pivot = begin;      //坑的位置
  15.      int left = begin;       //区间最左边
  16.      int right = end;    //区间最右边
  17.      while (left < right)
  18.      {
  19.          //right不断向左移动，找到小于key的数
  20.          while (left < right && nums[right] >= key)
  21.              right--;
  22.          //将满足条件的数“挖走”，并填入坑pivot中
  23.          nums[pivot] = nums[right];
  24.          //被挖走数字的区域变成新的坑
  25.          pivot = right;
  26.  ​
  27.          //left不断向右移动，找到大于key的数
  28.          while (left < right && nums[left] <= key)
  29.              left++;
  30.          //将满足条件的数“挖走”，并填入坑pivot中
  31.          nums[pivot] = nums[left];
  32.          //被挖走数字的区域变成新的坑
  33.          pivot = left;
  34.      }
  35.  ​
  36.      //将基准值填入最后坑的位置
  37.      nums[pivot] = key;
  38.  ​
  39.      QuickSort(nums, begin, pivot - 1);
  40.      QuickSort(nums, pivot + 1, end);
  41.  }
 

 

7 归并排序
 

以升序为例
 

基本思想：
 

  •  
    归并排序是建立在归并操作上的一种有效的排序算法，该算法是采用分治法的一个非常典型的应用：将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。
     
  •  
    如果对两个有序序列的归并操作还不太熟悉，建议先看看合并两个有序链表
     
 

核心步骤：
 

 

  •  
    由上图我们可以看到，归并排序首先要对待排序列不断二分，直到分成不可分割的子序列（即只有一个元素的序列，相当于有序）
     
  •  
    然后，再对有序的子序列不断进行归并操作，最后得到完全有序的序列。
     
  •  
    归并排序有递归和非递归两种写法，接下来我们来讨论如何实现的具体细节：
     
 

递归写法：
 

  •  
    首先我们要注意，在进行归并操作时，为了防止原序列的元素被覆盖而导致排序错误，我们需要向内存申请一块空间用来临时存放合并的序列，同时，由于归并的此时不止一次，为防止多次申请内存而导致效率不高，我们直接向内存申请一块和原序列大小相等的空间。
     
 

  1.  void MergeSort(int *nums, int numsSize)
  2.  {
  3.      int* temp = (int*)malloc(sizeof(int) * numsSize);
  4.      …………;
  5.      free(temp);                           
  6.  }
 

  •  
    同时，归并排序在进行归并操作时需要知道每个子序列的区间，由于递归参数的限制，我们需要再定义一个子函数MergeSort()，并对这个子函数递归
     
 

  1.  void _MergeSort(int *nums, int *temp, int left, int right)
  2.  {
  3.      …………;
  4.  }
  5.  ​
  6.  void MergeSort(int *nums, int numsSize)
  7.  {
  8.      int* temp = (int*)malloc(sizeof(int) * numsSize);
  9.      _MergeSort(nums, temp, 0, numsSize - 1);
  10.      free(temp);                           
  11.  }
 

  •  
    易知，当子序列长度为1时，就可以不再进行二分
     
 

  1.  void _MergeSort(int *nums, int *temp, int left, int right)
  2.  {
  3.      if (left >= right)
  4.          return;
  5.      …………;
  6.  }
 

  •  
    对待排序列的左半部分和右半部分不断递归分割
     
 

  1.  void _MergeSort(int *nums, int *temp, int left, int right)
  2.  {
  3.      if (left >= right)
  4.          return;
  5.  ​
  6.      int mid = (right - left) / 2 + left;
  7.      _MergeSort(nums, temp, left, mid);
  8.      _MergeSort(nums, temp, mid + 1, right);
  9.  ​
  10.      ……………;
  11.  }
 

  •  
    接下来，就是对两个有序序列的合并操作
     
  •  
    注：可以走到合并这一步说明待合并的两个序列[left,mid]和[mid + 1,right]是有序的，存在两种情况：
     
  
    •  
      情况一：例如序列{9,2}，进入函数_MergeSort()后，其子序列是单个数字，满足left >= right的条件，直接退出递归，开始合并。
       
    •  
      情况二：例如序列{9,2,5,4}，进入函数_MergeSort()后，子序列{9,2}递归，合并后退出递归，然后子序列{5,4}递归，合并，退出递归，最后就变成了两个有序序列{2,9}和{4,5}的合并
       
    •  
      建议对递归不是很清楚的小伙伴可以尝试画画递归展开图，这对了解递归逻辑大有裨益。
       
 

  1.  void _MergeSort(int *nums, int *temp, int left, int right)
  2.  {
  3.      if (left >= right)
  4.          return;
  5.  ​
  6.      //递归分割
  7.      int mid = (right - left) / 2 + left;
  8.      _MergeSort(nums, temp, left, mid);
  9.      _MergeSort(nums, temp, mid + 1, right);
  10.  ​
  11.      int begin1 = left, end1 = mid;
  12.      int begin2 = mid + 1, end2 = right;
  13.      int index = left;
  14.  ​
  15.      //归并
  16.      while (begin1 <= end1 && begin2 <= end2)
  17.      {
  18.          if (nums[begin1] > nums[begin2])
  19.              temp[index++] = nums[begin2++];
  20.          else
  21.              temp[index++] = nums[begin1++];
  22.      }
  23.      while (begin1 <= end1)
  24.          temp[index++] = nums[begin1++];
  25.      while (begin2 <= end2)
  26.          temp[index++] = nums[begin2++];
  27.  ​
  28.      //将temp暂时存储的数据覆盖待排序列nums原有位置的数据，实现待排序列区间有序
  29.      for (int i = left; i <= right; i++)
  30.          nums[i] = temp[i];
  31.  }
 

动图展示：
 

 

实现代码：
 

  1.  void _MergeSort(int *nums, int *temp, int left, int right)
  2.  {
  3.      if (left >= right)
  4.          return;
  5.  ​
  6.      //递归分割
  7.      int mid = (right - left) / 2 + left;
  8.      _MergeSort(nums, temp, left, mid);
  9.      _MergeSort(nums, temp, mid + 1, right);
  10.  ​
  11.      int begin1 = left, end1 = mid;
  12.      int begin2 = mid + 1, end2 = right;
  13.      int index = left;
  14.  ​
  15.      //归并
  16.      while (begin1 <= end1 && begin2 <= end2)
  17.      {
  18.          if (nums[begin1] > nums[begin2])
  19.              temp[index++] = nums[begin2++];
  20.          else
  21.              temp[index++] = nums[begin1++];
  22.      }
  23.      while (begin1 <= end1)
  24.          temp[index++] = nums[begin1++];
  25.      while (begin2 <= end2)
  26.          temp[index++] = nums[begin2++];
  27.  ​
  28.      //将temp暂时存储的数据覆盖待排序列nums原有位置的数据（拷贝回去），实现待排序列区间有序
  29.      for (int i = left; i <= right; i++)
  30.          nums[i] = temp[i];
  31.  }
  32.  ​
  33.  void MergeSort(int *nums, int numsSize)
  34.  {
  35.      int* temp = (int*)malloc(sizeof(int) * numsSize);
  36.      _MergeSort(nums, temp, 0, numsSize - 1);
  37.      free(temp);                           
  38.  }
 

7.1 非递归
 

  •  
    我们可以直接用循环解决问题，如图所示：
     
     
     
     
  •  
    由上面的递归分析可以知道，两个单个数字可以直接合并成一个有序序列。因此我们定义gap，表示每次合并的两个序列长度为gap，gap从1递增，直到不能满足条件gap < numsSize，然后就进行和递归相同的合并操作就可以了
     
 

  1.  void MergeSort(int* nums, int numsSize)
  2.  {
  3.      int* temp = (int*)malloc(sizeof(int) * numsSize);
  4.  ​
  5.      int gap = 1;
  6.  ​
  7.      while (gap < numsSize)
  8.      {
  9.          /*
  10.              因为每次是对两个有序序列进行合并
  11.              因此每次合并过后i应该跳过两个序列长度
  12.          */
  13.          for (int i = 0; i < numsSize; i += 2 * gap)
  14.          {
  15.              int begin1 = i, end1 = i + gap - 1;
  16.              int begin2 = i + gap, end2 = i + 2 * gap - 1;
  17.              int index = begin1;
  18.              
  19.              //归并
  20.              while (begin1 <= end1 && begin2 <= end2)
  21.              {
  22.                  if (nums[begin1] < nums[begin2])
  23.                      temp[index++] = nums[begin1++];
  24.                  else
  25.                      temp[index++] = nums[begin2++];
  26.              }
  27.              while(begin1 <= end1)
  28.                  temp[index++] = nums[begin1++];
  29.              while(begin2 <= end2)
  30.                  temp[index++] = nums[begin2++];
  31.              
  32.              //将temp暂时存储的数据覆盖待排序列nums原有位置的数据（拷贝回去），实现待排序列区间有序
  33.              for (int j = i; j <= end2; j++)
  34.                  nums[j] = temp[j];
  35.          }
  36.  ​
  37.          gap *= 2;
  38.      }
  39.  ​
  40.      free(temp);
  41.  }
 

处理边界情况：
 

  •  
    看起来好像很简单，但上面的代码仍存在些许bug，仍需要我们谨慎处理
     
  •  
    我们来看一个情况，如果给的待排数组是{5,4,3,2,9,7,1,6,8}
     
 

 

 

  •  
    如果给的待排数组是{5,4,3,2,9,7
     
 

 

 

  1.  int begin1 = i, end1 = i + gap - 1;
  2.  int begin2 = i + gap, end2 = i + 2 * gap - 1;
  3.  int index = begin1;
  4.  ​
  5.  /*
  6.      如果右半区间不存在，只有左半区间
  7.      说明待合并的只有一个区间
  8.      显然没有合并的必要，直接退出合并循环即可
  9.  */
  10.  if (begin2 >= numsSize)
  11.      break;
  12.  ​
  13.  //如果右半区间算多了，那么对end2进行修正
  14.  if (end2 >= numsSize)
  15.      end2 = numsSize - 1;
 

 

实现代码：
 

  1. void MergeSort(int* nums, int numsSize)
  2.  {
  3.      int* temp = (int*)malloc(sizeof(int) * numsSize);
  4.  ​
  5.      int gap = 1;
  6.  ​
  7.      while (gap < numsSize)
  8.      {
  9.          /*
  10.              因为每次是对两个有序序列进行合并
  11.              因此每次合并过后i应该跳过两个序列长度
  12.          */
  13.          for (int i = 0; i < numsSize; i += 2 * gap)
  14.          {
  15.              int begin1 = i, end1 = i + gap - 1;
  16.              int begin2 = i + gap, end2 = i + 2 * gap - 1;
  17.              int index = begin1;
  18.  ​
  19.              /*
  20.                  如果右半区间不存在，只有左半区间
  21.                  说明待合并的只有一个区间
  22.                  显然没有合并的必要，直接退出合并循环即可
  23.              */
  24.              if (begin2 >= numsSize)
  25.                  break;
  26.  ​
  27.              //如果右半区间算多了，那么对end2进行修正
  28.              if (end2 >= numsSize)
  29.                  end2 = numsSize - 1;
  30.              
  31.              
  32.               //归并
  33.              while (begin1 <= end1 && begin2 <= end2)
  34.              {
  35.                  if (nums[begin1] < nums[begin2])
  36.                      temp[index++] = nums[begin1++];
  37.                  else
  38.                      temp[index++] = nums[begin2++];
  39.              }
  40.              while(begin1 <= end1)
  41.                  temp[index++] = nums[begin1++];
  42.              while(begin2 <= end2)
  43.                  temp[index++] = nums[begin2++];
  44.              
  45.              //将temp暂时存储的数据覆盖待排序列nums原有位置的数据（拷贝回去），实现待排序列区间有序
  46.              for (int j = i; j <= end2; j++)
  47.                  nums[j] = temp[j];
  48.          }
  49.  ​
  50.          gap *= 2;
  51.      }
  52.  ​
  53.      free(temp);
  54.  }
 

时间复杂度：
 

  •  
    易得，合并两个有序序列的时间复杂度为O(N)
     
  •  
    由于是对待排序列的不断二分，知道分割为不可分割的子序列，因此这一过程的时间复杂度为O(logN)
     
  •  
    因此归并排序的时间复杂度为O(NlogN)
     
 

 

8 计数排序
 

以升序排序为例
 

什么是计数排序：
 

  •  
    计数排序是一个基于非比较的排序算法，该算法于1954年由 Harold H. Seward 提出
     
  •  
    基本思想：是对于给定的输入序列中的每一个元素x，确定该序列中值小于x的元素的个数（此处并非比较各元素的大小，而是通过对元素值的计数和计数值的累加来确定）。一旦有了这个信息，就可以将x直接存放到最终的输出序列的正确位置上。例如，如果输入序列中只有17个元素的值小于x的值，则x可以直接存放在输出序列的第18个位置上。当然，如果有多个元素具有相同的值时，我们不能将这些元素放在输出序列的同一个位置上，因此，上述方案还要作适当的修改。——百度百科
     
 

实现思路：
 

  •  
    根据待排序列的最大值和最小值，向系统申请一块空间
     
  •  
    空间内每个位置就代表着待排序列最小值到最大值每个数据的映射
     
  •  
    遍历待排序序列，统计每个数据出现的次数，并记录于申请的空间内
     
  •  
    最后根据空间中记录的每个数据出现的次数，实现对待排序列的排序
     
 

具体步骤：
 

  •  
    我们以数组{101,105,102,107,105,106}为例
     
  •  
    首先，我们遍历整个乱序序列，找到最大值max，最小值min，从而求出待排序列的数据范围range
     
 

  1.  for (int i = 0; i < numsSize; i++)
  2.  {
  3.      if (nums[i] > max)
  4.          max = nums[i];
  5.      if (nums[i] < min)
  6.          min = nums[i];
  7.  }
  8.  ​
  9.  int range = max - min + 1;
 

  •  
    向内存中申请range * sizeof(数据类型)大小的空间，并将其初始化为0（这块空间记录的是range范围内每个数据出现的次数，因此初始值为0）
     
 

  1.  int* count = (int*)malloc(sizeof(int) * range);     //申请内存
  2.  memset(count, 0, range * sizeof(int));      //初始化为0
 

 

 

  •  
    遍历乱序序列，记录每个数据出现的次数，并记录到申请的空间中
     
  •  
    那么问题来了，我们怎么得到每个数据在申请的空间中的位置呢？由上面的分析可以得到吗，空间的第一个位置即下标0处代表着最小值min（例子中的101），102就是101后面的一个数，下标就是102-101 = 1，103就是101后面的第二个数，下标就是103-101 = 2…………，因此数据nums[i]在count中的位置就是nums[i] - min
     
 

  1.  for (int i = 0; i < numsSize; i++)
  2.          count[nums[i] - min]++;
 

 

  •  
    由于申请的空间是range范围内从小到大的映射，这已经是一个升序序列，因此最后我们只需要根据空间中记录的每个数据出现的次数，将这些数据重新按顺序放到原序列中就可以实现升序排序了。
     
 

  1.  int cur = 0;
  2.  for (int i = 0; i < range; i++)
  3.  {
  4.      while (count[i]--)
  5.          nums[cur++] = i + min;
  6.  }
 

 

 

动图展示：
 

 

 

实现代码：
 

  1.  void CountSort(int* nums, int numsSize)
  2.  {
  3.      int max = nums[0];
  4.      int min = nums[0];
  5.  ​
  6.      for (int i = 0; i < numsSize; i++)
  7.      {
  8.          if (nums[i] > max)
  9.              max = nums[i];
  10.          if (nums[i] < min)
  11.              min = nums[i];
  12.      }
  13.  ​
  14.      int range = max - min + 1;
  15.      int* count = (int*)malloc(sizeof(int) * range);
  16.      memset(count, 0, range * sizeof(int));
  17.  ​
  18.      for (int i = 0; i < numsSize; i++)
  19.          count[nums[i] - min]++;
  20.  ​
  21.      int cur = 0;
  22.      for (int i = 0; i < range; i++)
  23.      {
  24.          while (count[i]--)
  25.              nums[cur++] = i + min;
  26.      }
  27.      
  28.      free(count);
  29.  }
 

 

时间复杂度：
 

  •  
    计数排序的时间复杂度为：O(N + K)，其中N为待排序列元素个数，K为待排序列数据范围（即range）
     
  •  
    是线性的时间复杂度，快于任何比较排序算法
     
  •  
    我们可以来看看对于排序一亿个数，它和快速排序所耗时间（单位为毫秒）的比较
     
 

 

  • 由此可见，对于整数的排序，计数排序的强大性
 

局限性：
 

  •  
    计数排序只能对整数排序
     
  •  
    如果数据范围range过大，那么不适合用计数排序来排
     
  
    •  
      例如，要对5个数排序，但这20个数的数据范围是一千万，这样像内存申请的空间就会很大，从而造成空间浪费
       
  •  
    当range > NlogN 时，计数排序的效率反而不如基于比较的排序算法，因为堆排序、希尔排序、快速排序、归并排序等排序时间复杂度的理论下限为O(NlogN)
     
 

 

9 八大排序稳定性分析
 

9.1 什么是稳定性
 

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

9.2 直接插入排序
 

  • 由于我们规定区间[0,end]内都是有序的只有满足nums[end + 1] < nums[end]（即end前面的数）时，nums[end + 1]才会向前移动，因此不存在相等的数被交换位置的情况。
  • 即直接插入排序时稳定的
 

9.3 希尔排序
 

  • 千万不要以为希尔排序是直接插入排序的优化，那希尔排序就是稳定的了
  • 由于希尔排序存在将间隔为gap的数据分成一组的操作，那我们就不能保证相等的数字会被分在同一组，也就不能保证预排序时相等的数字不会被打乱顺序
  • 因此希尔排序是不稳定的
 

9.4 直接选择排序
 

  • 如果用的方法是未改进的方法（即从左往右选，每次只选一个数），那么直接选择排序是稳定的
  • 而如果用的是改进后的方法（即逐渐缩小区间，每次选两个数），那么直接选择排序就是不稳定的，如图
 

 

  • 因此，直接选择排序可能是稳定的也可能是不稳定的 
 

9.5 堆排序
 

  • 如图所示
 

 

  • 即堆排序是不稳定的 
 

9.6 冒泡排序
 

  • 冒泡的过程中，只有满足nums[j + 1] < nums[j]才会发生交换，因此不会出现两个相等的数被交换位置的情况。
  • 即冒泡排序是稳定的
 

9.7 快速排序
 

  • 如图所示，用左右指针法实现快速排序
 

 

  •  可见，快速排序是不稳定的。
 

9.8 归并排序
 

  • 归并排序是通过对待排序列不断二分至不可分割的子序列，然后进行合并，这期间不会改变相等的元素的相对位置
  • 因此，归并排序是稳定的
 

9.9 计数排序
 

  • 计数排序是基于非比较的排序，自然就不存在数据之间的交换，也就不会改变相等元素的相对位置。
  • 即，计数排序是稳定的
 

 

10 总结
 

排序方法时间复杂度空间复杂度稳定性
直接插入排序O(N^2)O(1)稳定
希尔排序O(NLogN)O(1)不稳定
直接选择排序O(N^2)O(1)不确定
堆排序O(NLogN)O(1)不稳定
冒泡排序O(N^2)O(1)稳定
快速排序O(NLogN)O(LogN)~O(N)不稳定
归并排序O(NLogN)O(N)稳定
计数排序O(N)O(N)稳定
 

 

11 参考代码
 

  1. #include<stdio.h>
  2. #include<stdlib.h>
  3. #include<time.h>
  4. #include<stdbool.h>
  5. #include<assert.h>
  6.  
  7. #define N 100000
  8. /*****************************实现栈*****************************/
  9. typedef int StackDataType;
  10. typedef struct stack
  11. {
  12. 	StackDataType* stack;
  13. 	int top;
  14. }ST;
  15.  
  16. void StackInit(ST* st)
  17. {
  18. 	st->stack = (int*)malloc(sizeof(int) * N);
  19. 	st->top = 0;
  20. }
  21.  
  22. bool StackEmpty(ST* st)
  23. {
  24. 	return st->top == 0;
  25. }
  26.  
  27. void StackPush(ST* st, StackDataType val)
  28. {
  29. 	st->stack[st->top++] = val;
  30. }
  31.  
  32. void StackPop(ST* st)
  33. {
  34. 	assert(!StackEmpty(st));
  35. 	st->top--;
  36. }
  37.  
  38. StackDataType StackTop(ST* st)
  39. {
  40. 	assert(!StackEmpty(st));
  41. 	return st->stack[st->top - 1];
  42. }
  43.  
  44. /*****************************交换两数*****************************/
  45. void Swap(int* num1, int* num2)
  46. {
  47. 	int temp = *num1;
  48. 	*num1 = *num2;
  49. 	*num2 = temp;
  50. }
  51.  
  52. /*****************************直接插入排序*****************************/
  53. void InsertSort(int* nums, int numsSize)
  54. {
  55. 	for (int i = 0; i < numsSize - 1; i++)
  56. 	{
  57. 		int end = i;
  58. 		int temp = nums[end + 1];
  59. 		while (end >= 0)
  60. 		{
  61. 			if (temp < nums[end])
  62. 			{
  63. 				nums[end + 1] = nums[end];
  64. 				end--;
  65. 			}
  66. 			else
  67. 				break;
  68. 		}
  69. 		nums[end + 1] = temp;
  70. 	}
  71. }
  72.  
  73. /*****************************希尔排序*****************************/
  74. void ShellSort(int* nums, int numsSize)
  75. {
  76. 	int gap = numsSize / 2;
  77.  
  78. 	while (gap >= 1)
  79. 	{
  80. 		for (int i = 0; i < numsSize - gap; i++)
  81. 		{
  82. 			int end = i; 
  83. 			int temp = nums[end + gap];
  84. 			while (end >= 0)
  85. 			{
  86. 				if (temp < nums[end])
  87. 				{
  88. 					nums[end + gap] = nums[end];
  89. 					end -= gap;
  90. 				}
  91. 				else
  92. 					break;
  93. 			}
  94. 			nums[end + gap] = temp;
  95. 		}
  96. 		gap /= 2;
  97. 	}
  98. }
  99.  
  100. /*****************************直接选择排序（未改进）*****************************/
  101. void SelectSort_One(int* nums, int numsSize)
  102. {
  103. 	for (int i = 0; i < numsSize - 1; i++)
  104. 	{
  105. 		for (int j = i + 1; j < numsSize; j++)
  106. 		{
  107. 			if (nums[i] > nums[j])
  108. 				Swap(&nums[i], &nums[j]);
  109. 		}
  110. 	}
  111. }
  112.  
  113. /*****************************直接选择排序（改进）*****************************/
  114. void SelectSort_Two(int* nums, int numsSize)
  115. {
  116. 	int begin = 0;
  117. 	int end = numsSize - 1;
  118.  
  119. 	while (begin < end)
  120. 	{
  121. 		int max_index = begin;
  122. 		int min_index = begin;
  123.  
  124. 		for (int i = begin; i <= end; i++)
  125. 		{
  126. 			if (nums[i] > nums[max_index])
  127. 				max_index = i;
  128. 			if (nums[i] < nums[min_index])
  129. 				min_index = i;
  130. 		}
  131.  
  132. 		Swap(&nums[begin], &nums[min_index]);
  133. 		if (max_index == begin)
  134. 			max_index = min_index;
  135. 		Swap(&nums[end], &nums[max_index]);
  136.  
  137. 		begin++;
  138. 		end--;
  139. 	}
  140. }
  141.  
  142. /*****************************堆排序*****************************/
  143. //ChildLeft = 2 * Parent + 1
  144. //ChildRight = 2 * Parent + 2
  145. //Parent = (Child - 1) / 2
  146.  
  147. //向下调整算法
  148. void AdjustDown(int* nums, int numsSize, int root)
  149. {
  150. 	int parent = root;
  151. 	int child_max = parent * 2 + 1;
  152. 	while (child_max < numsSize)
  153. 	{
  154. 		if (child_max + 1 < numsSize && nums[child_max] < nums[child_max + 1])
  155. 			child_max++;
  156. 		if (nums[child_max] > nums[parent])
  157. 			Swap(&nums[child_max], &nums[parent]);
  158. 		else
  159. 			break;
  160. 		parent = child_max;
  161. 		child_max = parent * 2 + 1;
  162. 	}
  163. }
  164. void HeapSort(int* nums, int numsSize)
  165. {
  166. 	//建堆
  167. 	int root = (numsSize - 1 - 1) / 2;
  168. 	for (int i = root; i >= 0; i--)
  169. 		AdjustDown(nums, numsSize, i);
  170.  
  171. 	//排序
  172. 	while (numsSize)
  173. 	{
  174. 		Swap(&nums[0], &nums[numsSize - 1]);
  175. 		AdjustDown(nums, --numsSize, 0);
  176. 	}
  177. }
  178.  
  179. /*****************************冒泡排序*****************************/
  180. void BubbleSort(int* nums, int numsSize)
  181. {
  182. 	for (int i = 0; i < numsSize - 1; i++)
  183. 	{
  184. 		int flag = 1;
  185. 		for (int j = 0; j < numsSize - i - 1; j++)
  186. 		{
  187. 			if (nums[j] > nums[j + 1])
  188. 			{
  189. 				Swap(&nums[j], &nums[j + 1]);
  190. 				flag = 0;
  191. 			}
  192. 		}
  193. 		if (flag == 1)
  194. 			break;
  195. 	}
  196. }
  197.  
  198. /*****************************快速排序*****************************/
  199. //三数取中
  200. int FindMid(int *nums, int left, int right)
  201. {
  202. 	int mid = (right - left) / 2 + left;
  203. 	if (nums[left] < nums[mid])
  204. 	{
  205. 		if (nums[right] > nums[mid])
  206. 			return mid;
  207. 		else if (nums[right] < nums[left])
  208. 			return left;
  209. 		else
  210. 			return right;
  211. 	}
  212. 	else	//nums[mid] < nums[left]
  213. 	{
  214. 		if (nums[right] > nums[left])
  215. 			return left;
  216. 		else if (nums[right] < nums[mid])
  217. 			return mid;
  218. 		else
  219. 			return right;
  220. 	}
  221. }
  222. //挖坑法
  223. int PartSort_One(int* nums, int left, int right)
  224. {
  225. 	int begin = left;
  226. 	int end = right;
  227. 	int privot = begin;
  228.  
  229. 	int index = FindMid(nums, begin, end);
  230. 	Swap(&nums[begin], &nums[index]);
  231.  
  232. 	int key = nums[begin];
  233.  
  234. 	while (begin < end)
  235. 	{
  236. 		while (begin < end && nums[end] >= key)
  237. 			end--;
  238. 		nums[privot] = nums[end];
  239. 		privot = end;
  240.  
  241. 		while (begin < end && nums[begin] <= key)
  242. 			begin++;
  243. 		nums[privot] = nums[begin];
  244. 		privot = begin;
  245. 	}
  246. 	nums[privot] = key;
  247.  
  248. 	return privot;
  249.  
  250. }
  251. //左右指针法
  252. int PartSort_Two(int* nums, int left, int right)
  253. {
  254. 	int begin = left;
  255. 	int end = right;
  256.  
  257. 	int index = FindMid(nums, begin, end);
  258. 	Swap(&nums[begin], &nums[index]);
  259.  
  260. 	int key = nums[begin];
  261.  
  262. 	while (begin < end)
  263. 	{
  264. 		while (begin < end && nums[end] >= key)
  265. 			end--;
  266. 		while (begin < end && nums[begin] <= key)
  267. 			begin++;
  268.  
  269. 		Swap(&nums[end], &nums[begin]);
  270. 	}
  271. 	Swap(&nums[left], &nums[end]);
  272.  
  273. 	return end;
  274. }
  275. //前后指针法、
  276. int PartSort_Three(int* nums, int left, int right)
  277. {
  278. 	int index = FindMid(nums, left, right);
  279. 	Swap(&nums[left], &nums[index]);
  280.  
  281. 	int key = nums[left];
  282. 	int prev = left;
  283. 	int cur = prev + 1;
  284.  
  285. 	while (cur <= right)
  286. 	{
  287. 		if (nums[cur] < key && ++prev != cur)
  288. 			Swap(&nums[cur], &nums[prev]);
  289. 		cur++;
  290. 	}
  291. 	Swap(&nums[left], &nums[prev]);
  292.  
  293. 	return prev;
  294. }
  295. //递归
  296. void QuickSort(int* nums, int left, int right)
  297. {
  298. 	if (left >= right)
  299. 		return;
  300.  
  301. 	/*int keyindex = PartSort_One(nums, left, right);*/
  302. 	/*int keyindex = PartSort_Two(nums, left, right);*/
  303. 	int keyindex = PartSort_Three(nums, left, right);
  304.  
  305. 	QuickSort(nums, left, keyindex - 1);
  306. 	QuickSort(nums, keyindex + 1, right);
  307. }
  308. //非递归
  309. void QuickSort_NoRecursive(int* nums, int numsSize)
  310. {
  311. 	ST* st = (ST*)malloc(sizeof(ST));
  312. 	StackInit(st);
  313.  
  314. 	StackPush(st, numsSize - 1);
  315. 	StackPush(st, 0);
  316.  
  317. 	while (!StackEmpty(st))
  318. 	{
  319. 		int begin = StackTop(st);
  320. 		StackPop(st);
  321. 		int end = StackTop(st);
  322. 		StackPop(st);
  323.  
  324. 		int key_index = PartSort_One(nums, begin, end);
  325.  
  326. 		if (key_index - begin > 0)
  327. 		{
  328. 			StackPush(st, key_index - 1);
  329. 			StackPush(st, begin);
  330. 		}
  331. 			
  332. 		if (end - key_index > 0)
  333. 		{
  334. 			StackPush(st, end);
  335. 			StackPush(st, key_index + 1);
  336. 		}
  337. 	}
  338.  
  339. 	free(st);
  340. }
  341.  
  342. /*****************************归并排序*****************************/
  343. void _MergeSort(int* nums, int* temp, int left, int right)
  344. {
  345. 	if (left >= right)
  346. 		return;
  347.  
  348. 	int mid = (right - left) / 2 + left;
  349.  
  350. 	_MergeSort(nums, temp, left, mid);
  351. 	_MergeSort(nums, temp, mid + 1, right);
  352.  
  353. 	int begin1 = left, end1 = mid;
  354. 	int begin2 = mid + 1, end2 = right;
  355. 	int index = left;
  356.  
  357. 	while (begin1 <= end1 && begin2 <= end2)
  358. 	{
  359. 		if (nums[begin1] < nums[begin2])
  360. 			temp[index++] = nums[begin1++];
  361. 		else
  362. 			temp[index++] = nums[begin2++];
  363. 	}
  364. 	while (begin1 <= end1)
  365. 		temp[index++] = nums[begin1++];
  366. 	while (begin2 <= end2)
  367. 		temp[index++] = nums[begin2++];
  368.  
  369. 	for (int i = left; i <= right; i++)
  370. 		nums[i] = temp[i];
  371. }
  372. //递归
  373. void MergeSort(int* nums, int numsSize)
  374. {
  375. 	int* temp = (int*)malloc(sizeof(int) * numsSize);
  376. 	_MergeSort(nums, temp, 0, numsSize - 1);
  377. 	free(temp);
  378. }
  379. //非递归
  380. void MergeSort_NoRecursive(int* nums, int numsSize)
  381. {
  382. 	int* temp = (int*)malloc(sizeof(int) * numsSize);
  383.  
  384. 	int gap = 1;
  385. 	while (gap < numsSize)
  386. 	{
  387. 		for (int i = 0; i < numsSize; i += 2 * gap)
  388. 		{
  389. 			int begin1 = i, end1 = i + gap - 1;
  390. 			int begin2 = i + gap, end2 = i + 2 * gap - 1;
  391. 			int index = begin1;
  392.  
  393. 			if (end2 >= numsSize)
  394. 				end2 = numsSize - 1;
  395. 			if (begin2 >= numsSize)
  396. 				break;
  397.  
  398. 			while (begin1 <= end1 && begin2 <= end2)
  399. 			{
  400. 				if (nums[begin1] < nums[begin2])
  401. 					temp[index++] = nums[begin1++];
  402. 				else
  403. 					temp[index++] = nums[begin2++];
  404. 			}
  405. 			while (begin1 <= end1)
  406. 				temp[index++] = nums[begin1++];
  407. 			while (begin2 <= end2)
  408. 				temp[index++] = nums[begin2++];
  409.  
  410. 			for (int j = i; j <= end2; j++)
  411. 				nums[j] = temp[j];
  412. 		}
  413. 		gap *= 2;
  414. 	}
  415.  
  416. 	free(temp);
  417. }
  418.  
  419. /*****************************计数排序*****************************/
  420. void CountSort(int* nums, int numsSize)
  421. {
  422. 	int min = nums[0];
  423. 	int max = nums[0];
  424.  
  425. 	for (int i = 0; i < numsSize; i++)
  426. 	{
  427. 		if (nums[i] > max)
  428. 			max = nums[i];
  429. 		if (nums[i] < min)
  430. 			min = nums[i];
  431. 	}
  432.  
  433. 	int range = max - min + 1;
  434. 	int* Count = (int*)malloc(sizeof(int) * range);
  435. 	memset(Count, 0, range * sizeof(int));
  436.  
  437. 	for (int i = 0; i < numsSize; i++)
  438. 		Count[nums[i] - min]++;
  439.  
  440. 	int index = 0;
  441. 	for (int i = 0; i < range; i++)
  442. 	{
  443. 		while (Count[i]--)
  444. 			nums[index++] = i + min;
  445. 	}
  446. }
  447.  
  448. /*****************************打印数组*****************************/
  449. void PrintArr(int* nums, int numsSize)
  450. {
  451. 	for (int i = 0; i < numsSize; i++)
  452. 		printf("%d ", nums[i]);
  453. 	printf("\n");
  454. }
  455.  
  456. /*****************************测试*****************************/
  457. void TextInsertSort()
  458. {
  459. 	int *nums = (int *)malloc(sizeof(int) * N);
  460. 	for (int i = 0; i < N; i++)
  461. 		nums[i] = rand() % N + 1;
  462.  
  463. 	int begin_time = clock();
  464. 	InsertSort(nums, N);
  465. 	int end_time = clock();
  466.  
  467. 	printf("InsertSort : %d\n", end_time - begin_time);
  468.  
  469. //	PrintArr(nums, len);
  470. }
  471.  
  472. void TextShellSort()
  473. {
  474. 	int* nums = (int*)malloc(sizeof(int) * N);
  475. 	for (int i = 0; i < N; i++)
  476. 		nums[i] = rand() % N + 1;
  477.  
  478. 	int begin_time = clock();
  479. 	ShellSort(nums, N);
  480. 	int end_time = clock();
  481.  
  482. 	printf("ShellSort : %d\n", end_time - begin_time);
  483.  
  484. 	//	PrintArr(nums, len);
  485. }
  486.  
  487. void TextSelectSort_One()
  488. {
  489. 	int* nums = (int*)malloc(sizeof(int) * N);
  490. 	for (int i = 0; i < N; i++)
  491. 		nums[i] = rand() % N + 1;
  492.  
  493. 	int begin_time = clock();
  494. 	SelectSort_One(nums, N);
  495. 	int end_time = clock();
  496.  
  497. 	printf("SelectSort_One : %d/ms\n", end_time - begin_time);
  498.  
  499. 	//	PrintArr(nums, len);
  500. }
  501.  
  502. void TextSelectSort_Two()
  503. {
  504. 	int* nums = (int*)malloc(sizeof(int) * N);
  505. 	for (int i = 0; i < N; i++)
  506. 		nums[i] = rand() % N + 1;
  507.  
  508. 	int begin_time = clock();
  509. 	SelectSort_Two(nums, N);
  510. 	int end_time = clock();
  511.  
  512. 	printf("SelectSort_Two : %d/ms\n", end_time - begin_time);
  513.  
  514. 	//	PrintArr(nums, len);
  515. }
  516.  
  517. void TextHeapSort()
  518. {
  519. 	int* nums = (int*)malloc(sizeof(int) * N);
  520. 	for (int i = 0; i < N; i++)
  521. 		nums[i] = rand() % N + 1;
  522.  
  523. 	int begin_time = clock();
  524. 	HeapSort(nums, N);
  525. 	int end_time = clock();
  526.  
  527. 	printf("HeapSort : %d\n", end_time - begin_time);
  528.  
  529. 	//	PrintArr(nums, len);
  530. }
  531.  
  532. void TextBubbleSort()
  533. {
  534. 	int* nums = (int*)malloc(sizeof(int) * N);
  535. 	for (int i = 0; i < N; i++)
  536. 		nums[i] = rand() % N + 1;
  537.  
  538. 	int begin_time = clock();
  539. 	BubbleSort(nums, N);
  540. 	int end_time = clock();
  541.  
  542. 	printf("BubbleSort : %d\n", end_time - begin_time);
  543.  
  544. 	//	PrintArr(nums, len);
  545. }
  546.  
  547. void TextQuickSort()
  548. {
  549. 	int* nums = (int*)malloc(sizeof(int) * N);
  550. 	for (int i = 0; i < N; i++)
  551. 		nums[i] = rand() % N + 1;
  552.  
  553. 	int begin_time = clock();
  554. 	QuickSort(nums, 0, N - 1);
  555. 	int end_time = clock();
  556.  
  557. 	printf("QuickSort : %d\n", end_time - begin_time);
  558.  
  559. 	//	PrintArr(nums, len);
  560. }
  561.  
  562. void TextQuickSort_NoRecursive()
  563. {
  564. 	int* nums = (int*)malloc(sizeof(int) * N);
  565. 	for (int i = 0; i < N; i++)
  566. 		nums[i] = rand() % N + 1;
  567.  
  568. 	int begin_time = clock();
  569. 	QuickSort_NoRecursive(nums, N);
  570. 	int end_time = clock();
  571.  
  572. 	printf("QuickSort_NoRecursive : %d\n", end_time - begin_time);
  573.  
  574. 	//	PrintArr(nums, len);
  575. }
  576.  
  577. void TextMergeSort()
  578. {
  579. 	int* nums = (int*)malloc(sizeof(int) * N);
  580. 	for (int i = 0; i < N; i++)
  581. 		nums[i] = rand() % N + 1;
  582.  
  583. 	int begin_time = clock();
  584. 	MergeSort(nums, N);
  585. 	int end_time = clock();
  586.  
  587. 	printf("MergeSort : %d\n", end_time - begin_time);
  588.  
  589. 	//	PrintArr(nums, len);
  590. }
  591.  
  592. void TextMergeSort_NoRecursive()
  593. {
  594. 	int* nums = (int*)malloc(sizeof(int) * N);
  595. 	for (int i = 0; i < N; i++)
  596. 		nums[i] = rand() % N + 1;
  597.  
  598. 	int begin_time = clock();
  599. 	MergeSort_NoRecursive(nums, N);
  600. 	int end_time = clock();
  601.  
  602. 	printf("MergeSort_NoRecursive : %d\n", end_time - begin_time);
  603.  
  604. 	//	PrintArr(nums, len);
  605. }
  606.  
  607. void TextCountSort()
  608. {
  609. 	int* nums = (int*)malloc(sizeof(int) * N);
  610. 	for (int i = 0; i < N; i++)
  611. 		nums[i] = rand() % N + 1;
  612.  
  613. 	int begin_time = clock();
  614. 	CountSort(nums, N);
  615. 	int end_time = clock();
  616.  
  617. 	printf("CountSort : %d\n", end_time - begin_time);
  618.  
  619. 	//	PrintArr(nums, len);
  620. }
  621.  
  622. /*****************************主函数*****************************/
  623. int main()
  624. {
  625. 	srand((unsigned int)time(NULL));
  626.  
  627. 	TextInsertSort();
  628. 	TextShellSort();
  629. 	TextSelectSort_One();
  630. 	TextSelectSort_Two();
  631. 	TextHeapSort();
  632. 	TextBubbleSort();
  633. 	TextQuickSort();
  634. 	TextQuickSort_NoRecursive();
  635. 	TextMergeSort();
  636. 	TextMergeSort_NoRecursive();
  637. 	TextCountSort();
  638.  
  639. 	return 0;
  640. }
 

 

 12 八大排序效率比较
 

对于十万个整数，各排序消耗的时间（毫秒）：
 

 

 

 

13 结语
 

由于本片篇幅较长，难免会有疏忽错误的地方，欢迎各位指出，斧正；以及，如果大家对文章格式、排版有什么建议，也欢迎私信，博主会不断改进。
 

这篇博客可以说是博主迄今为止投入时间最长的一篇博客了，如果觉得这篇文章对你有所帮助的话，还请不要吝啬你的点赞、收藏加关注呀!
 

最后，博主仍会继续学习，不断创作出更加优质的内容供大家参考，学习。
 

共勉！！！(￣y▽￣)╭ Ohohoho.....
 

 


                

        
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家自动化/article/detail/454410
推荐阅读
相关标签
Copyright ©  2003-2013 www.wpsshop.cn  版权所有，并保留所有权利。

  
闽ICP备14008679号