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

七大排序算法 - 冒泡、简单选择、直接插入、希尔、堆、归并、快速

作者：码创造者 | 2024-08-19 03:01:38

赞

踩

顺序表上实现排序的各种方法

点击上方，选择“置顶公众号”

优质文章，第一时间送达

640?

排序的相关概念

排序的分类

  • 根据在排序过程中带排序的记录是否全部被放置在内存中，排序分为：

1.内排序

内排序是在排序整个过程中，带排序的所有记录全部放置在内存中。

影响内排序的主要因素

  • 时间性能。

    • (主要受比较和移动两种操作的影响）

  • 辅助空间。

  • 算法的复杂性。

内排序的分类

根据排序过程中借助的主要操作，内排序分为：

  • 插入排序

  • 交换排序

  • 选择排序

  • 归并排序

2.外排序

外排序是由于排序的记录个数太多，不能同时放置在内存中，整个排序过程需要在内外存之间多次交换数据才能进行。

按照算法的复杂度分类

  • 简单算法：

    • 冒泡排序、简单选择排序、直接插入排序。

  • 复杂排序：

    • 希尔排序、堆排序、归并排序、快速排序。

一、冒泡排序算法

因为在冒泡排序中要用到顺序表结构和数组两元素的交换，先把这些写成函数

  1. #include <stdio.h>	
  2. #include <stdlib.h>	
  3.  
  4. 	
  5. #define MAXSIZE 100	
  6. #define TRUE 1	
  7. #define FALSE 0	
  8.  
  9. 	
  10. typedef struct {	
  11.     	
  12.     int r[MAXSIZE + 1];	
  13.     int length;	
  14. }SqList;	
  15.  
  16. 	
  17.  
  18. 	
  19. void swap(SqList *L, int i, int j){	
  20.     int temp = L->r[i];	
  21.     L->r[i] = L->r[j];	
  22.     L->r[j] = temp;	
  23. }

1.1 冒泡排序的初级版实现

冒泡排序（Bubble Sort）是一种交换排序，它的基本思想是：两两比较相邻记录的关键字，如果反序则交换，直到没有反序的记录为止。

  1. void BubblSort0(SqList *L){	
  2.  
  3. 	
  4.     int i,j;	
  5.     	
  6.     for (i = 1; i < L->length; i++)	
  7.         for (j = i+1; j <= L->length; j++)	
  8.             if (L->r[i] > L->r[j])	
  9.                 swap(L, i, j);	
  10. }

对于这段代码，是最简单的冒泡，其实就是最简单的交换排序而已。它的思路就是让每一个关键字，都和它后面的每一个关键字比较，如果大则交换，这样第一位置的关键字在第一次循环后一定变成最小值。

假设我们待排序的关键字序列是{9，1，5，8，3，7，4，6，2}

  • 当i = 1时，9与1交换后，在第一位置的1与后面的关键字比较都小，因此它就只最小值。

  • 当i = 2时，第二位置先后由9换成5，换成3，换成2，完成了第二小的数字交换。

  • 后面数字依次比较和交换，得到最终结果。

640

1.2 冒泡排序的实现

对于上面的算法，代码虽然简单易懂，但是效率非常低。可以改进成接下来的代码

  1. void BubbleSort(SqList *L){	
  2.     int i,j;	
  3.     for (i = 1; i < L->length; i++)	
  4.         for (j = L->length - 1; j >= i; j--)	
  5.             if (L->r[j] > L->r[j+1])	
  6.                 swap(L, j, j+1);	
  7. }
代码解释

假设我们待排序的关键字序列是{9，1，5，8，3，7，4，6，2}

  • 当i = 1时，变量j由8反向循环到1，逐个比较，将较小值交换到前面，直到最后找到最小值放置在了第1的位置。

  • 当i = 1、 j = 8时，6 > 2 ，因此交换了它们的位置，j = 7时，4 > 2， 所以交换......直到j = 2时，因为 1 < 2， 所以不交换。

  • j = 1 时，9 > 1，交换，最终得到最小值1放置第一的位置。

  • 在不断循环的过程中，除了将关键字1放到第一的位置，还将关键字2从第九位置提到了第三的位置，显然比前面的算法有进步。

  • 当i = 2时，变量j由8反向循环到2，逐个比较，在将关键字2交换到第二位置的同时，也将关键字4和3有所提升。

1.3 冒泡排序的优化

  • 在排序的过程中，增加一个标记变量flag来记录位置是否发生了变化

  • 如果没有发生交换，说明数组已经有序了。

  1. void BubbleSort1(SqList *L){	
  2.     int i,j;	
  3.     	
  4.     int flag = TRUE;	
  5.     for (i = 1; i < L->length && flag; i++) {	
  6.         flag = FALSE;	
  7.         for (j = L->length - 1; j >= i; j--) {	
  8.             if (L->r[j] > L->r[j+1]) {	
  9.                 swap(L, j, j+1);	
  10.                 flag = TRUE;	
  11.             }	
  12.         }	
  13.     }	
  14. }

测试

  1. #define N 9	
  2. int main(int argc, const char * argv[]) {	
  3.     	
  4.     int i;	
  5.     int d[N] = {9,1,5,8,3,7,4,6,2};	
  6.     	
  7.     SqList l0;	
  8.     for (i = 0; i < N; i++)	
  9.         l0.r[i+1] = d[i];	
  10.     l0.length = N;	
  11.     	
  12.     printf("排序前：\n");	
  13.     for (i = 0; i < l0.length; i++) {	
  14.         printf("%d ", l0.r[i+1]);	
  15.     }	
  16.     printf("\n");	
  17.     	
  18.  
  19. 	
  20.     printf("1.0 初级冒泡排序结果:\n");	
  21.     BubblSort0(&l0);	
  22.     for (i = 0; i < l0.length; i++) {	
  23.         printf("%d ", l0.r[i+1]);	
  24.     }	
  25.     printf("\n");	
  26.     	
  27.     printf("1.1 冒泡排序结果:\n");	
  28.     BubbleSort(&l0);	
  29.     for (i = 0; i < l0.length; i++) {	
  30.         printf("%d ", l0.r[i+1]);	
  31.     }	
  32.     printf("\n");	
  33.  
  34. 	
  35.     printf("1.2 优化后冒泡排序结果:\n");	
  36.     BubbleSort1(&l0);	
  37.     for (i = 0; i < l0.length; i++) {	
  38.         printf("%d ", l0.r[i+1]);	
  39.     }	
  40.     printf("\n");	
  41.  
  42. 	
  43.     return 0;	
  44. }

测试结果

640

二、简单选择排序

简单选择排序法(Simple Selection Sort)是通过n-i次关键字间的比较，从n-i+1个记录中选出关键字最小的记录，并和第i(1<=i<=n)个记录交换。

简单选择排序法的工作原理是：每一次从无序组的数据元素中选出最小（或最大）的一个元素，存放在无序组的起始位置，无序组元素减少，有序组元素增加，直到全部待排序的数据元素排完。

  1. void SelectSort(SqList *L){	
  2.     int i, j, min;	
  3.     for (i = 1; i < L->length; i++) {	
  4.         min = i;	
  5.         for (j = i + 1; j <= L->length; j++) {	
  6.             if (L->r[min] > L->r[j])	
  7.                 min = j;	
  8.         }	
  9.         	
  10.         if (i != min)  	
  11.             swap(L, i, min);	
  12.     }	
  13. }

代码说明

  • 简单选择排序相对简单，交换移动数据的次数相当少，节约时间。

  • 简单选择排序的时间复杂度为O(n^2)。

三、直接插入排序

直接插入排序(Straight Insertion Sort)的基本操作是将一个记录插入到已经排好序的有序表中，从而得到一个新的、记录增1的有序表。

直接插入排序的核心思想：将一个记录插入到一个已经排序好的表中，以得到一个记录增加1的有序表。并且它把当前元素大的记录都往后移动，用以腾出“自己”该插入的位置。当n-1趟插入完成后该记录就是有序序列。

  1.  
  2. 	
  3. void InsertSort(SqList *L){	
  4.     int i, j;	
  5.     for (i = 2; i < L->length; i++) {	
  6.         	
  7.         if (L->r[i] < L->r[i-1]) {	
  8.             	
  9.             L->r[0] = L->r[i];	
  10.             for (j = i-1; L->r[j] > L->r[0]; j++)	
  11.                 L->r[j+1] = L->r[i];	
  12.             	
  13.             L->r[j+1] = L->r[0];	
  14.         }	
  15.     }	
  16. }

代码说明

  • 直接插入排序的时间复杂度为O(n^2)。

  • 直接插入排序比冒泡和简单选择排序的性能要好一些。

四、希尔排序

希尔排序是对直接插入排序的改进：

  • 将原本有大量记录数的记录进行分组。分割成若干个子序列；

  • 对子序列分别进行直接插入排序；

  • 当整个序列都基本有序时（注意是基本有序），再对全体记录进行一次直接插入排序。

  • 所谓的基本有序，就是小的关键字基本在前，大的基本在后面，不大不小的基本在中间，如{9,1,5,8,3,7,5,6,2}，变成{2,1,3,6,4,7,8,9}这样就是基本有序，但是像{1,5,9,7,8,2,4,6}这样9在第三位，2在倒数第三位就不是基本有序。

  • 对于分割子序列，采取跳跃分割的策略：

  • 将相距某个“增量”的记录组成一个子序列，这样才能保证在子序列内分别进行直接插入排序后得到的结果是基本有序而不是局部有序。

  • 增量的选取非常关键，但是现在还是一个数学难题(迄今没有找到一种最好的增量序列),大量研究表明，增量序列为dlta[k] = 2^(t-k+1) - 1时，可以获得不错的效果。

希尔排序的核心思想：希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止

  1. void ShellSort(SqList *L){	
  2.     	
  3.     int i,j;	
  4.     	
  5.     int increment = L->length;	
  6.     	
  7.     do {	
  8.         increment = increment /3 +1;	
  9.         	
  10.         for (i = increment + 1; i < L->length; i++) {	
  11.             	
  12.             if (L->r[i] < L->r[i-increment]) {	
  13.                 	
  14.                 L->r[0] = L->r[i];	
  15.                 	
  16.                 for (j = i - increment; i >0 && L->r[0] < L->r[j]; j -= increment)	
  17.                     L->r[j+increment] = L->r[j];	
  18.                     	
  19.                 L->r[j+increment] = L->r[0];	
  20.             }	
  21.         }	
  22.     } while (increment > 1);	
  23. }

代码说明

  • 希尔排序的时间复杂度为O(n^(3/2))，要好于直接插入排序的O(n^2);

  • 增量的最后一个增量之必须等于1才行。

  • 由于记录是跳跃式的移动，所以希尔排序不是一种稳定的排序算法。

五、堆排序

堆的概念

堆是具有如下性质的完全二叉树：

  • 每个结点的值都大于或等于其其左右孩子结点的值，为大顶堆。

  • 或者每个结点的值都小于或等于其左右孩子结点的值，称为小顶堆。

  • 因此根节点一定是堆中所有结点最大（小）者。

  • 如图左边为大顶堆，右边为小顶堆：

    640

    左边为大顶堆，右边为小顶堆

堆排序算法

堆排序（Heap Sort）是利用堆（假设是大顶堆）进行排序。堆排序的核心思想：

  • 将待排序的序列构造成一个大顶堆。

  • 此时，整个序列的最大值就是堆顶的根节点。

  • 将根节点移走(其实就是将它与堆数组的末尾元素交换，此时末尾元素就是最大值)，然后将剩余的n-1个序列重新构造成一个堆，这样就会得到n个元素的次小值。

  • 重复上诉操作，便能得到一个有序序列。

640

堆排序算法核心

  • 如何由一个无序序列构建成一个堆

  • 如何在输出堆顶元素后，调整剩余元素成一个新的堆

堆排序算法代码实现
  1. void HeadAdjust(SqList *L, int s, int m){	
  2.  
  3. 	
  4.     int temp, j;	
  5.     temp = L->r[s];	
  6.     	
  7.     for (j = 2 *s; j <= m; j *= 2) {	
  8.         	
  9.         if (j < m && L->r[j] < L->r[j+1])	
  10.             j++;	
  11.         	
  12.         if (temp >= L->r[j])	
  13.             break;	
  14.         	
  15.         L->r[s] = L->r[j];	
  16.         s = j;	
  17.     }	
  18.     	
  19.     L->r[s] = temp;	
  20. }	
  21.  
  22. 	
  23.  
  24. 	
  25. void HeapSort(SqList *L){	
  26.     int i;	
  27.     	
  28.     for (i = L->length / 2; i>0; i--)	
  29.         HeadAdjust(L, i, L->length);	
  30.     	
  31.     for (i = L->length; i > 1; i--) {	
  32.         swap(L, 1, i);	
  33.         HeadAdjust(L, 1, i-1);	
  34.     }	
  35. }
堆排序算法代码说明

  • 堆排序方法HeapSort中有两个for循环：

  • 第一个for循环完成将现在的待排序序列构建成一个大顶堆；

  • 第二个for循环完成逐渐将每个最大值的根节点与末尾元素交换，并且再调整其成为大顶堆。

    • 第一个for循环中的i = L->length / 2,i从[9/2]=4开始，4->3->2->1的变化量。

    • （这里赋值的原因是这些都是有孩子的结点）

    • 构建好有孩子的结点之后，就可以从上到下、从左到右，将每个将每个非终端结点（非叶子结点）当做根节点,将其和子树调整成大顶堆。

  • 函数HeadAdjust的作用是将数组构建成一个大顶堆，在构建的时候利用了二叉树的性质。

  • 构建堆的时间复杂度为O(n)，重建堆的时间复杂度为O(nlogn)，所以总体来说堆排序的时间复杂度为O(nlogn)，性能上远好于冒泡、简单选择、直接插入的时间复杂度。

  • 在空间复杂度上，由于记录的交换和比较是跳跃式进行的，所以堆排序是一种不稳定的排序方法。

六、归并排序

归并排序(Merging Sort)是利用归并的思想实现的。2路归并排序的核心思想如下：

  • 假设初始序列有n个记录，则可以看成是n个有序的子序列，每个子序列的长度为1，然后两两归并，得到n/2个长度为2或者1的有序子序列

  • 再两两归并...如此重复，直至得到一个长度为n的有序序列为止。

6.1归并排序的实现思路（递归实现）

  • 将序列平均分成两部分

  • 分别对这两部分用递归来归并

  • 将这两部分归并到一起

归并排序的代码实现（递归实现）
  1. #pragma - 6.归并排序(递归实现)	
  2.  
  3. 	
  4. void Merge(int SR[], int TR[], int i, int m, int n){	
  5.     	
  6.     int j, k, l;	
  7.     	
  8.     for (j = m+1, k = i; i <= m && j <= n; k++) {	
  9.         	
  10.         if (SR[i] < SR[j])	
  11.             TR[k] = SR[i++];	
  12.         else	
  13.             TR[k] = SR[j++];	
  14.     }	
  15.     	
  16.     if (i <= m) {	
  17.         for (l=0; l <= m-i; l++)	
  18.             TR[k+l] = SR[i+l];	
  19.     }	
  20.     	
  21.     if (j <= n) {	
  22.         for (l=0; l <= n-j; l++)	
  23.             TR[k+l] = SR[j+l];	
  24.     }	
  25. }	
  26.  
  27. 	
  28.  
  29. 	
  30. void MSort(int SR[], int TR1[], int s, int t){	
  31.  
  32. 	
  33.     int m;	
  34.     int TR2[MAXSIZE+1];	
  35.     	
  36.     if (s == t) {	
  37.         TR1[s] = SR[s];	
  38.     }else{	
  39.         m = (s+t)/2;	
  40.         MSort(SR, TR2, s, m);	
  41.         MSort(SR, TR2, m+1, t);	
  42.         Merge(TR2, TR1, s, m, t);	
  43.     }	
  44. }	
  45.  
  46. 	
  47.  
  48. 	
  49. void MergeSort(SqList *L){	
  50.     MSort(L->r, L->r, 1, L->length);	
  51. }

归并排序的总结（递归实现）

  • 归并排序总的时间复杂度为O(nlogn)，并且这是归并排序算法中最好、最坏、平均的时间性能。

  • 归并排序的空间复杂度为O(n+logn)

  • 归并排序是一种比较占内存，但是效率高且稳定的算法。

6.2归并排序的实现（迭代非递归实现）

用迭代实现的话，可以从最小的序列开始归并直到完成。

  1. #pragma - 7.归并排序（迭代实现）	
  2.  
  3. 	
  4. void MergePass(int SR[], int TR[], int s, int n){	
  5.     	
  6.     int i = 1;	
  7.     int j;	
  8.     	
  9.     while (i <= n-2*s+1) {	
  10.         Merge(SR, TR, i, i+s-1, i+2*s-1);	
  11.         i = i+2*s;	
  12.     }	
  13.     	
  14.     if (i < n-s+1)	
  15.         Merge(SR, TR, i, i+s-1, n);	
  16.     else	
  17.         for (j = i; j <= n; j++)	
  18.             TR[j] = SR[j];	
  19. }	
  20.  
  21. 	
  22.  
  23. 	
  24. void MergeSort2(SqList *L){	
  25.     	
  26.     int * TR = (int *)malloc(sizeof(L->length*sizeof(int)));	
  27.     int k = 1;	
  28.     	
  29.     while (k < L->length) {	
  30.         MergePass(L->r, TR, k, L->length);	
  31.         k = 2*k;	
  32.         	
  33.         MergePass(TR, L->r, k, L->length);	
  34.         k = 2*k;	
  35.     }	
  36. }

归并的迭代实现总结

  • 非递归的迭代方法，避免了递归时深度为log2n的栈空间，空间只是用到申请归并临时用的TR数组，因此空间复杂度为O(n).

  • 并且相对于递归，在时间性能上也有一定的提升，所以使用归并时，尽量使用非递归实现。

七、快速排序

快速排序(Quick Sort)的基本思想是：

  • 通过一趟排序将待排序记录分割成独立的两部分

  • 其中一部分记录的关键字均比另一部分记录的关键字小；

  • 则可分别对这两部分记录继续进行排序，以达到整个序列有序的目的。

快速排序的实现思路

  • 选取一个关键字，放到一个位置，使得它的左边的值都比它小，右边的值都比它大，这个关键字叫做枢轴（pivot)

  • 然后分别对左边和右边进行排序。

快速排序的代码实现

  1. #pragma - 8.快速排序	
  2.  
  3. 	
  4. int Partition(SqList * L, int low, int high){	
  5.     	
  6.     int pivotkey;	
  7.     pivotkey = L->r[low];	
  8.     	
  9.     while (low < high) {	
  10.         while (low < high && L->r[high] >= pivotkey)	
  11.             high --;	
  12.         swap(L, low, high);	
  13.         	
  14.         while (low < high && L->r[low] <= pivotkey)	
  15.             high++;	
  16.         swap(L, low, high);	
  17.     }	
  18.     	
  19.     return low;	
  20. }	
  21.  
  22. 	
  23.  
  24. 	
  25. void QSort(SqList *L, int low, int high){	
  26.     	
  27.     int pivot;	
  28.     if (low < high) {	
  29.         pivot = Partition(L, low, high);	
  30.         QSort(L, low, pivot-1);	
  31.         QSort(L, pivot+1, high);	
  32.     }	
  33. }	
  34.  
  35. 	
  36. void QuickSort(SqList *L){	
  37.     QSort(L, 1, L->length);	
  38. }

快速排序的代码说明

  • Partition函数就是将选取的pivotkey不断交换，将比它小的换到它的左边，比它大的交换到它的右边，它也在交换中不断更改自己的位置，直到完全满足这个要求为止。

  • 快速排序的时间性能取决于快速递归的深度，快排的时间复杂度为O(nlogn)。

  • 快速排序的空间复杂度主要是递归造成的栈空间的使用，平均情况下空间复杂度为O(nlogn)。

  • 由于关键字的比较和交换是跳跃进行的，因此，快排是一种不稳定的排序算法

快速排序的优化

  1. 优化选取枢轴在上面的代码中，选取枢轴的方式为：

  2. pivotkey = L->r[low]，即用序列的第一个元素作为枢轴，这是理想情况下 L->r[low]是中间数。

  3. 但是对于其他情况，这种固定选取第一个关键子作为首个枢轴的方法就不是很合理。

    于是可以用下面的方法优化：

  • 三数取中(median-of-three)法：

  • 取三个关键子进行排序，将中间数作为枢轴，一般取左端、右端和中间三个数，也可以随机选取。

  • 九数取中(median-of-nine)法：

  • 先从数组中分三次取样，每次取三个数，三个样品各取中数，然后从这三个数当中再取出一个中数作为枢轴

三数取中(median-of-three)法代码：

  1.  
  2. 	
  3.  
  4. 	
  5.     int pivotkey;	
  6.     	
  7.     int m = low + (high - low)/2;	
  8.     	
  9.     if (L->r[low] > L->r[high])	
  10.         swap(L, low, high);	
  11.     	
  12.     if (L->r[m] > L->r[high])	
  13.         swap(L, high, m);	
  14.     if (L->r[m] > L->r[low])	
  15.         swap(L, m, low);	
  16.     	
  17.     pivotkey = L->r[low];

  1. 优化不必要的交换

  2. 优化小数组时的排序方案

  3. 优化递归操作

快速排序优化后的代码
  1. int Partition1(SqList * L, int low, int high){	
  2.     	
  3.     int pivotkey;	
  4.     	
  5.     int m = low + (high - low)/2;	
  6.     	
  7.     if (L->r[low] > L->r[high])	
  8.         swap(L, low, high);	
  9.     	
  10.     if (L->r[m] > L->r[high])	
  11.         swap(L, high, m);	
  12.     if (L->r[m] > L->r[low])	
  13.         swap(L, m, low);	
  14.     	
  15.     pivotkey = L->r[low];	
  16.     L->r[0] = pivotkey;	
  17.     	
  18.     while (low < high) {	
  19.         while (low < high && L->r[high] >= pivotkey)	
  20.             high--;	
  21.         L->r[low] = L->r[high];	
  22.         	
  23.         while (low < high && L->r[low] <= pivotkey)	
  24.             low++;	
  25.         L->r[high] = L->r[low];	
  26.     }	
  27.     	
  28.     L->r[low] = L->r[0];	
  29.     	
  30.     return low;	
  31. }	
  32.  
  33. 	
  34.  
  35. 	
  36.  
  37. 	
  38. void QSort1(SqList *L, int low, int high){	
  39.     	
  40.     int pivot;	
  41.     if ((high -low) > MAX_LINEGIH_INSERT_SORT) {	
  42.         while (low < high) {	
  43.             pivot = Partition1(L, low, high);	
  44.             QSort1(L, low, pivot-1);	
  45.  
  46. 	
  47.             	
  48.             low = pivot+1;	
  49.         }	
  50.     }else	
  51.         InsertSort(L);	
  52. }	
  53.  
  54. 	
  55.  
  56. 	
  57. void QuickSort1(SqList *L){	
  58.     QSort1(L, 1, L->length);	
  59. }

  • 希尔排序相当于直接插入排序的升级，同属于插入排序类

  • 堆排序相当于简单选择排序的升级，同属于选择排序类

  • 快速排序相当于冒泡排序的升级，同属于交换排序类

原文：https://www.jianshu.com/p/876931436177

作者：STzen

推荐阅读

1. 

2. 

3. 

4. 

640?

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

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号