博客
关于我
强烈建议你试试无所不能的chatGPT,快点击我
数据结构【排序】—排序算法大集合
阅读量:6479 次
发布时间:2019-06-23

本文共 23573 字,大约阅读时间需要 78 分钟。

影响排序性能的要素

  时间性能;
  辅助空间
  算法的复杂度
简单排序【n^2】
  算法思想:
    第一趟:
      从第一个记录开始,通过n-1次关键字比较,从n个记录中选出最小的并和第一个记录交换;
     第二趟:
      从第二个记录开始,通过n-2次关键字比较,从n -1个记录中选出最小的并和第二个记录交换;

  

1 /**************************简单排序****************************/ 2 //初级冒泡排序,就是一个一个与后面对比 3 void  BubbleSort0(SqList* &l,int (&a)[2]) { 4     for (int i = 1; i < l->len; ++i) { 5         for (int j = i + 1; j <= l->len; ++j) { 6             a[0]++; 7             if (l->v[i] > l->v[j]){ 8                 swap(l->v[i], l->v[j]); 9                 a[1]++;10             }11         }12     }13 }

 

冒泡排序【n^2】:

  冒泡排序(Bubble Sort)一种交换排序,它的基本思想是:两两比较相邻记录的关键字,如果反序则交换,直到没有反序的记录为止。
  从末尾两两比较将最小数浮上来!

1 /**************************冒泡排序****************************/ 2 //冒泡排序,两两比较排序 3 void BubbleSort(SqList* &l, int(&a)[2]) { 4     for (int i = 1; i < l->len; ++i) { 5         for (int j = l->len - 1; j >= i; --j) { 6             a[0]++; 7             if (l->v[j + 1] < l->v[j]) { 8                 swap(l->v[j + 1], l->v[j]); 9                 a[1]++;10             }11         }12     }13 }
1 /**************************改进冒泡排序****************************/ 2 //改进冒泡排序,加入哨兵模式 3 void BubbleSort2(SqList* &l, int(&a)[2]) { 4     bool flag = true;//哨兵 5     for (int i = 1; flag&&i < l->len; ++i) { 6         flag = false; 7         for (int j = l->len - 1; j >= i; --j) { 8             a[0]++; 9             if (l->v[j + 1] < l->v[j]) {10                 a[1]++;11                 swap(l->v[j + 1], l->v[j]);12                 flag = true;//数据交换后才需要遍历13             }14         }15     }16 }

 

选择比较【n^2】:

  简单选择排序法(Simple Selection Sort)就是通过n-i次关键字间的比较,从n-i+1个记录中选出关键字最小的坐标记录,并和第i(1<i<n)个记录交换之。找到最小值,然后依次放到前到后的值;

1 /**************************选择排序****************************/ 2 //选择排序,就是依次找出未排序中的最小值放入前面 3 void SelectSort(SqList* &l, int(&a)[2]) { 4     int i, j, min; 5     for (i = 1; i < l->len; ++i) { 6         min = i; 7         for (j = i + 1; j < l->len; ++j) { 8             a[0]++; 9             if (l->v[min] > l->v[j])10                 min = j;11         }12         if (i != min) {13             swap(l->v[min], l->v[i]);14             a[1]++;15         }16     }17 }

 

直接插入排序【n^2】:

  直接插入排序(Straight Insertion Sort)的基本操作是将一个记录插入到已经排好序的有序表中,从而得到一个新的、记录数增1的有序表。
  即:从前向后两两比较,若第二个数为小的数,然后将该数记住,从此位置从后向前比较该数,并将比他大的数向后挪,直到找到存放该数的位置
  此算法需要一个辅助的临时空间存放:
  算法思想:将第i个记录插入到前面已经排好序的i - 1个记录中去。

  算法要点:

    ·使用监视哨r[0]临时保存带插入记录
    ·从后往前查找应插入的位置
    ·查找与移动用同一循环完成
    ·算法时间复杂度:o(n^2)

1 /**************************插值排序****************************/ 2 //插值排序,就是从前向后两两比较,若第二个数为小的数,然后将该数记住, 3 //从此位置从后向前比较该数,并将比他大的数向后挪,直到找到存放该数的位置 4 //此算法需要一个辅助的临时空间存放: 5  6 void InsertSort(SqList* &l, int(&a)[2]) { 7     int i, j; 8     for (int i = 2; i < l->len; ++i) { 9         a[0]++;10         if (l->v[i] < l->v[i - 1]) {
//找到了前比后大的数11 l->v[0] = l->v[i];//设置哨兵12 for (j = i - 1; l->v[0] < l->v[j]; --j) {
//返回比较13 a[1]++;14 l->v[j + 1] = l->v[j];//大的数向后挪15 }16 l->v[j+1] = l->v[0];17 }18 }19 }

折半插入排序:

  算法思想:

    利用折半查找的思想找到需要插入的位置
  算法时间复杂度:
    o(n^2),虽然减少了查找插入位置的次数,但是移动元素的时间仍未改变
希尔排序【nlogn】:
  将相距某个“增量”的记录组成一个子序列,这样才能保证在子序列内分别进行直接插入排序后得到的结果是基本有序而不是局部有序。
  与直接插入排序很相似,但需要一个变动的跨度n进行比较,然后第二次跨度为n-1进行比较
  算法思想:
    将待排序的关键字序列分成若干个较小的子序列,对子序列进行直接插入排序,使整个待排序序列排好序。

1 /**************************希尔排序****************************/ 2 //希尔排序 3 //与插值排序很像,不过是间隔比较 4 void ShellSort(SqList* &l, int(&a)[2]) { 5     int gap = l->len; 6     int i, j; 7     do { 8         gap = gap / 3 + 1;//间隔大小 9         for (i = gap + 1; i < l->len; ++i) {10             a[0]++;11             if (l->v[i] < l->v[i - gap]) {12                 l->v[0] = l->v[i];13                 for (j = i - gap; j > 0 && l->v[0] < l->v[j]; j -= gap) {
//向前去排序14 l->v[j + gap] = l->v[j];//大数向后移;15 a[1]++;16 }17 l->v[j + gap] = l->v[0];//插入18 }19 }20 } while (gap > 1);21 }

堆排序【nlogn】:

  堆是具有下列性质的完全二叉树:每个结点的值都大于或等于其左右孩子结点的值,称为大顶堆;或者每个结点的值都小于或等于其左右孩子结点的值,称为小顶堆。

  

1 /**************************************堆排序*****************************/ 2 //调整为大根堆 3 void HeapAdjust(SqList* &l, int n, int len) { 4     int temp = l->v[n]; 5     for (int i = 2 * n; i <= len; i *= 2) {
//沿着关键字中较大的孩子结构向在筛选 6 if (i < len&&l->v[i] < l->v[i + 1])++i;//i为关键字中较大的记录的下标 7 if (temp >= l->v[i])break;//找到插入的位置了 8 l->v[n] = l->v[i];// 9 n = i;10 }11 l->v[n] = temp;//进行插入12 }13 14 //堆排序15 void HeapSort(SqList* &l, int(&a)[2]) {16 for (int i = l->len / 2; i > 0; --i) {
//把数组中的数据变为一个大堆17 a[0]++;18 HeapAdjust(l, i, l->len);19 }20 for (int i = l->len; i > 1; --i) {21 a[1]++;22 swap(l->v[1], l->v[i]);/* 将堆顶记录和当前未经排序子序列的最后一个记录交换 */23 HeapAdjust(l, 1, i - 1);/* 将L->r[1..i-1]重新调整为大根堆 */24 }25 }

  算法思想:

  将向量中存储的数据看成一棵完全二叉树,利用完全二叉树中双亲节点和孩子节点之间的内在关系选择关键字最小的记录。

    ·将待排序的序列构造成一个大顶堆。
    ·此时,整个序列的最大值就是堆顶的根结点。将它移走(其实就是将其与堆数组的末尾元素交换,此时末尾元素就是最大值),
    ·然后将剩余的n-1个序列重新构造成一个堆,这样就会得到n个元素中的次大值。
    ·如此反复执行,便能得到一个有序序列了。
  大根堆:
    根节点最大;
    各节点关键字满足:a[i] >= a[2i]并且a[i] >= a[2i + 1]
  小根堆:
    根节点最小;
    各节点关键字满足:a[i] <= a[2i]并且a[i] <= a[2i+1]
归并排序:
    归并排序(Merging Sort)就是利用归并的思想实现的排序方法。它的原理是假设初始序列含有n个记录,则可以看成是n个有序的子序列,每个子序列的长度为1,然后两两归并,得到[n/21([x1表示不小于x的最小整数)个长度为2或1的有序子序列;再两两归并,……,如此重复,直至得到一个长度为n的有序序列为止,这种排序方法称为2路归并排序。
  算法思想:
  设初始序列长度为n,将这n个序列看成n个有序的子序列,然后辆辆合并,得到一个ceil(n/2)长度为2的有序子序列。
  在此基础上再对长度为2 的有序子序列进行归并排序,得到若干长度为4的子序列,如此重复直到得到一个长度为n的有序子序列为止

  

1 /**************************递归法归并+排序****************************/ 2 /* 将有序的SR[i..m]和SR[m+1..n]归并为有序的TR[i..n] */ 3 //归并 4 void Merge(int *SR, int *TR, int pot, int m, int len) { 5     int i,j,k; 6     for (i = m + 1, k = pot; pot <= m && i <= len; ++k) {
/*将SR中记录由小到大地并入TR * /*/ 7 if (SR[pot] < SR[i])TR[k] = SR[pot++]; 8 else TR[k] = SR[i++]; 9 }10 if (pot <= m)11 for (j = 0; j <= m; ++j)12 TR[k + j] = SR[pot + j]; /* 将剩余的SR[i..m]复制到TR */13 if (i <= len)14 for (j = 0; j <= len - i; ++j)15 TR[k + j] = SR[i + j];/* 将剩余的SR[j..n]复制到TR */16 }17 //进行递归18 void MSort(int *SR,int*TR1,int pot, int len, int(&a)[2]) {19 int TR2[MAXSIZE + 1];20 if (len == pot)21 TR1[pot] = SR[pot];22 else {23 int m = (len + pot) / 2; //将原数组平分两个数组24 a[0]++;25 MSort(SR, TR2, pot, m, a); /* 递归地将SR[pot..m]归并为有序的TR2[pot..m] */26 MSort(SR, TR2, m + 1, len, a); /* 递归地将SR[m+1..len]归并为有序的TR2[m+1..len] */27 Merge(TR2, TR1, pot, m, len); /* 将TR2[pot..m]和TR2[m+1..t]归并到TR1[pot..len] */28 a[1]++;29 }30 31 }32 33 //递归法归并排序34 void MergeSort(SqList* &l, int(&a)[2]) {35 MSort(l->v,l->v,1, l->len,a);36 }37 38 /**************************非递归法归并排序****************************/39 /*将SR[]中相邻长度为s的子序列两两归并到TR[] * /*/40 void MergePass(int *SR, int *TR, int k, int len, int(&a)[2]) {41 int i = 1, j;42 a[1]++;43 while (i <= len - 2 * k + 1) {44 //两两归并45 Merge(SR, TR, i, i + k - 1, len);46 i = i + 2 * k;47 }48 if (i < len - k + 1)//归并最后两个序列49 Merge(SR, TR, i, i + k - 1, len);50 else//最后只剩下单个序列51 for (j = i; j <= len; ++j)52 TR[j] = SR[j];53 } 54 //归并排序55 void MergeSort2(SqList* &l, int(&a)[2]) {56 int *TR = new int[l->len];57 int k = 1;58 while (k < l->len) {59 a[0]++;60 MergePass(l->v, TR, k, l->len, a);61 k = k * 2;//加长子序列62 MergePass(TR, l->v, k, l->len, a);63 k = 2 * k;//子序列加长64 }65 }

    

快速排序:

  快速排序(Quick Sort)的基本思想是:通过一趟排序将待排记录分割成独立的两部分,其中一部分记录的关键字均比另一部分记录的关键字小,则可分别对这两部分记录继续进行排序,以达到整个序列有序的目的。
  算法思想:
    从待排序记录中选择一个记录为枢纽,设为K,将其余大于K的记录移动至K的后面,小于K的移动至前面,此过程称为一趟快速排序。当然就是对接下来的两个字表进行相同的操作,直到子表的长度不超过1
  算法时间复杂度:
    O(Knlog2n),K为常数因子,且在所有O(nlogn)复杂度中,快排的K值最小

  

1 /**************************快速排序****************************/ 2 /* 交换顺序表L中子表的记录,使枢轴记录到位,并返回其所在位置 */ 3 /* 此时在它之前(后)的记录均不大(小)于它。 */ 4 //即处于枢轴的数的左边比其小,右边比其大 5 int Partiton(SqList* &l, int pot, int len, int(&a)[2]) { 6     int pkey; 7     pkey = l->v[pot];//假设第一个位置的数就是枢轴的位置 8     while (pot < len) { 9         a[0]++;10         while (pot < len&&l->v[len] >= pkey)//确保右边大于关键数11             len--;12         a[1]++;13         swap(l->v[pot], l->v[len]);//将比关键数小的数放置到关键数的左边14         a[0]++;15         while (pot < len&&l->v[pot] <= pkey)//确保左边的 数小于关键数16             pot++;17         a[1]++;18         swap(l->v[pot], l->v[len]);//将比关键数大的数放置到关键数的右边19     }20     return pot;//返回关键数的位置21 }22 23 /* 对顺序表L中的子序列L->r[low..high]作快速排序 */24 void QSort(SqList* &l, int pot, int len, int(&a)[2]) {25     int pivot;26     if (pot < len) {27         pivot = Partiton(l, pot, len, a);/*  将L->r[low..high]一分为二,算出枢轴值pivot */28         QSort(l, pot, pivot - 1, a);/*  对低子表递归排序 */29         QSort(l, pivot + 1, len, a);/*  对高子表递归排序 */30     }31 }32 void QuickSort(SqList* &l, int(&a)[2]) {33     QSort(l, 1, l->len, a);34 }35 36 /**************************改进快速排序****************************/37 //快速排序的优化38 int Partiton1(SqList* &l, int pot, int len, int(&a)[2]) {39     int pkey;40 41     /////改进之处,之间选中间作为关键数的位置42     int m = pot + (len - pot) / 2;43     a[0]++;44     if (l->v[pot] > l->v[len]) {45         swap(l->v[pot], l->v[len]);/* 交换左端与右端数据,保证左端较小 */46         a[1]++;47     }48     a[0]++;49     if (l->v[m] > l->v[len]) {50         swap(l->v[m], l->v[len]);/* 交换中间与右端数据,保证中间较小 */51         a[1]++;52     }53     a[0]++;54     if (l->v[m] < l->v[pot]) {55         swap(l->v[m], l->v[pot]);/* 交换中间与左端数据,保证左端较小 */56         a[1]++;57     }58     /////59     pkey = l->v[pot];//假设第一个位置的数就是枢轴的位置60     l->v[0] = pkey;//保留61     while (pot < len) {
/*从表的两端交替地向中间扫描 */62 a[0]++;63 while (pot < len&&l->v[len] >= pkey)//确保右边大于关键数64 --len;65 l->v[pot] = l->v[len];66 a[0]++;67 while (pot < len&&l->v[pot] <= pkey)//确保左边的 数小于关键数68 ++pot;69 l->v[len] = l->v[pot];70 }71 l->v[pot] = l->v[0];72 return pot;//返回关键数的位置73 }74 75 void QSort1(SqList* &l, int pot, int len, int(&a)[2]) {76 int pivot;77 if ((len - pot) > MAX_LENGTH_INSERT_SORT) {78 while (pot < len) {79 pivot = Partiton1(l, pot, len, a);/* 将L->r[low..high]一分为二,算出枢轴值pivot */80 QSort1(l, pot, pivot - 1, a);/* 对低子表递归排序 */81 pot = pivot + 1;//尾递归82 }83 }84 else85 InsertSort(l,a);86 }87 88 void QuickSort1(SqList* &l, int(&a)[2]) {89 QSort1(l, 1, l->len, a);90 }

 

总结:

  

  

  从算法的简单性来看,我们将7种算法分为两类:

  ·简单算法:冒泡、简单选择、直接插入。

  ·改进算法:希尔、堆、归并、快速。

 

完整代码:

  

1 #include "000库函数.h"  2   3 #define MAX_LENGTH_INSERT_SORT 7 /* 用于快速排序时判断是否选用插入排序阙值 */  4 #define MAXSIZE 100  /* 用于要排序数组个数最大值,可根据需要修改 */  5 #define N 9  6 struct SqList  7 {  8     int v[MAXSIZE+1];//用于存储要排序的数组,r[0]作为哨兵或临时存放变量  9     int len;//记录顺序表的长度 10 }; 11  12 //数据交换 13 void swap(int &i, int &j) { 14     int temp; 15     temp = i; 16     i = j; 17     j = temp; 18 } 19  20 /**************************简单排序****************************/ 21 //初级冒泡排序,就是一个一个与后面对比 22 void  BubbleSort0(SqList* &l,int (&a)[2]) { 23     for (int i = 1; i < l->len; ++i) { 24         for (int j = i + 1; j <= l->len; ++j) { 25             a[0]++; 26             if (l->v[i] > l->v[j]){ 27                 swap(l->v[i], l->v[j]); 28                 a[1]++; 29             } 30         } 31     } 32 } 33  34 /**************************冒泡排序****************************/ 35 //冒泡排序,两两比较排序 36 void BubbleSort(SqList* &l, int(&a)[2]) { 37     for (int i = 1; i < l->len; ++i) { 38         for (int j = l->len - 1; j >= i; --j) { 39             a[0]++; 40             if (l->v[j + 1] < l->v[j]) { 41                 swap(l->v[j + 1], l->v[j]); 42                 a[1]++; 43             } 44         } 45     } 46 } 47  48 /**************************改进冒泡排序****************************/ 49 //改进冒泡排序,加入哨兵模式 50 void BubbleSort2(SqList* &l, int(&a)[2]) { 51     bool flag = true;//哨兵 52     for (int i = 1; flag&&i < l->len; ++i) { 53         flag = false; 54         for (int j = l->len - 1; j >= i; --j) { 55             a[0]++; 56             if (l->v[j + 1] < l->v[j]) { 57                 a[1]++; 58                 swap(l->v[j + 1], l->v[j]); 59                 flag = true;//数据交换后才需要遍历 60             } 61         } 62     } 63 } 64  65 /**************************选择排序****************************/ 66 //选择排序,就是依次找出未排序中的最小值放入前面 67 void SelectSort(SqList* &l, int(&a)[2]) { 68     int i, j, min; 69     for (i = 1; i < l->len; ++i) { 70         min = i; 71         for (j = i + 1; j < l->len; ++j) { 72             a[0]++; 73             if (l->v[min] > l->v[j]) 74                 min = j; 75         } 76         if (i != min) { 77             swap(l->v[min], l->v[i]); 78             a[1]++; 79         } 80     } 81 } 82  83 /**************************插值排序****************************/ 84 //插值排序,就是从前向后两两比较,若第二个数为小的数,然后将该数记住, 85 //从此位置从后向前比较该数,并将比他大的数向后挪,直到找到存放该数的位置 86 //此算法需要一个辅助的临时空间存放: 87  88 void InsertSort(SqList* &l, int(&a)[2]) { 89     int i, j; 90     for (int i = 2; i < l->len; ++i) { 91         a[0]++; 92         if (l->v[i] < l->v[i - 1]) {
//找到了前比后大的数 93 l->v[0] = l->v[i];//设置哨兵 94 for (j = i - 1; l->v[0] < l->v[j]; --j) {
//返回比较 95 a[1]++; 96 l->v[j + 1] = l->v[j];//大的数向后挪 97 } 98 l->v[j+1] = l->v[0]; 99 }100 }101 }102 103 /**************************希尔排序****************************/104 //希尔排序105 //与插值排序很像,不过是间隔比较106 void ShellSort(SqList* &l, int(&a)[2]) {107 int gap = l->len;108 int i, j;109 do {110 gap = gap / 3 + 1;//间隔大小111 for (i = gap + 1; i < l->len; ++i) {112 a[0]++;113 if (l->v[i] < l->v[i - gap]) {114 l->v[0] = l->v[i];115 for (j = i - gap; j > 0 && l->v[0] < l->v[j]; j -= gap) {
//向前去排序116 l->v[j + gap] = l->v[j];//大数向后移;117 a[1]++;118 }119 l->v[j + gap] = l->v[0];//插入120 }121 }122 } while (gap > 1);123 }124 125 /**************************************堆排序*****************************/126 //调整为大根堆127 void HeapAdjust(SqList* &l, int n, int len) {128 int temp = l->v[n];129 for (int i = 2 * n; i <= len; i *= 2) {
//沿着关键字中较大的孩子结构向在筛选130 if (i < len&&l->v[i] < l->v[i + 1])++i;//i为关键字中较大的记录的下标131 if (temp >= l->v[i])break;//找到插入的位置了132 l->v[n] = l->v[i];//133 n = i;134 }135 l->v[n] = temp;//进行插入136 }137 138 //堆排序139 void HeapSort(SqList* &l, int(&a)[2]) {140 for (int i = l->len / 2; i > 0; --i) {
//把数组中的数据变为一个大堆141 a[0]++;142 HeapAdjust(l, i, l->len);143 }144 for (int i = l->len; i > 1; --i) {145 a[1]++;146 swap(l->v[1], l->v[i]);/* 将堆顶记录和当前未经排序子序列的最后一个记录交换 */147 HeapAdjust(l, 1, i - 1);/* 将L->r[1..i-1]重新调整为大根堆 */148 }149 }150 151 /**************************递归法归并+排序****************************/152 /* 将有序的SR[i..m]和SR[m+1..n]归并为有序的TR[i..n] */153 //归并154 void Merge(int *SR, int *TR, int pot, int m, int len) {155 int i,j,k;156 for (i = m + 1, k = pot; pot <= m && i <= len; ++k) {
/*将SR中记录由小到大地并入TR * /*/157 if (SR[pot] < SR[i])TR[k] = SR[pot++];158 else TR[k] = SR[i++];159 }160 if (pot <= m)161 for (j = 0; j <= m; ++j)162 TR[k + j] = SR[pot + j]; /* 将剩余的SR[i..m]复制到TR */163 if (i <= len)164 for (j = 0; j <= len - i; ++j)165 TR[k + j] = SR[i + j];/* 将剩余的SR[j..n]复制到TR */166 }167 //进行递归168 void MSort(int *SR,int*TR1,int pot, int len, int(&a)[2]) {169 int TR2[MAXSIZE + 1];170 if (len == pot)171 TR1[pot] = SR[pot];172 else {173 int m = (len + pot) / 2; //将原数组平分两个数组174 a[0]++;175 MSort(SR, TR2, pot, m, a); /* 递归地将SR[pot..m]归并为有序的TR2[pot..m] */176 MSort(SR, TR2, m + 1, len, a); /* 递归地将SR[m+1..len]归并为有序的TR2[m+1..len] */177 Merge(TR2, TR1, pot, m, len); /* 将TR2[pot..m]和TR2[m+1..t]归并到TR1[pot..len] */178 a[1]++;179 }180 181 }182 183 //递归法归并排序184 void MergeSort(SqList* &l, int(&a)[2]) {185 MSort(l->v,l->v,1, l->len,a);186 }187 188 /**************************非递归法归并排序****************************/189 /*将SR[]中相邻长度为s的子序列两两归并到TR[] * /*/190 void MergePass(int *SR, int *TR, int k, int len, int(&a)[2]) {191 int i = 1, j;192 a[1]++;193 while (i <= len - 2 * k + 1) {194 //两两归并195 Merge(SR, TR, i, i + k - 1, len);196 i = i + 2 * k;197 }198 if (i < len - k + 1)//归并最后两个序列199 Merge(SR, TR, i, i + k - 1, len);200 else//最后只剩下单个序列201 for (j = i; j <= len; ++j)202 TR[j] = SR[j];203 } 204 //归并排序205 void MergeSort2(SqList* &l, int(&a)[2]) {206 int *TR = new int[l->len];207 int k = 1;208 while (k < l->len) {209 a[0]++;210 MergePass(l->v, TR, k, l->len, a);211 k = k * 2;//加长子序列212 MergePass(TR, l->v, k, l->len, a);213 k = 2 * k;//子序列加长214 }215 }216 217 /**************************快速排序****************************/218 /* 交换顺序表L中子表的记录,使枢轴记录到位,并返回其所在位置 */219 /* 此时在它之前(后)的记录均不大(小)于它。 */220 //即处于枢轴的数的左边比其小,右边比其大221 int Partiton(SqList* &l, int pot, int len, int(&a)[2]) {222 int pkey;223 pkey = l->v[pot];//假设第一个位置的数就是枢轴的位置224 while (pot < len) {225 a[0]++;226 while (pot < len&&l->v[len] >= pkey)//确保右边大于关键数227 len--;228 a[1]++;229 swap(l->v[pot], l->v[len]);//将比关键数小的数放置到关键数的左边230 a[0]++;231 while (pot < len&&l->v[pot] <= pkey)//确保左边的 数小于关键数232 pot++;233 a[1]++;234 swap(l->v[pot], l->v[len]);//将比关键数大的数放置到关键数的右边235 }236 return pot;//返回关键数的位置237 }238 239 /* 对顺序表L中的子序列L->r[low..high]作快速排序 */240 void QSort(SqList* &l, int pot, int len, int(&a)[2]) {241 int pivot;242 if (pot < len) {243 pivot = Partiton(l, pot, len, a);/* 将L->r[low..high]一分为二,算出枢轴值pivot */244 QSort(l, pot, pivot - 1, a);/* 对低子表递归排序 */245 QSort(l, pivot + 1, len, a);/* 对高子表递归排序 */246 }247 }248 void QuickSort(SqList* &l, int(&a)[2]) {249 QSort(l, 1, l->len, a);250 }251 252 /**************************改进快速排序****************************/253 //快速排序的优化254 int Partiton1(SqList* &l, int pot, int len, int(&a)[2]) {255 int pkey;256 257 /////改进之处,之间选中间作为关键数的位置258 int m = pot + (len - pot) / 2;259 a[0]++;260 if (l->v[pot] > l->v[len]) {261 swap(l->v[pot], l->v[len]);/* 交换左端与右端数据,保证左端较小 */262 a[1]++;263 }264 a[0]++;265 if (l->v[m] > l->v[len]) {266 swap(l->v[m], l->v[len]);/* 交换中间与右端数据,保证中间较小 */267 a[1]++;268 }269 a[0]++;270 if (l->v[m] < l->v[pot]) {271 swap(l->v[m], l->v[pot]);/* 交换中间与左端数据,保证左端较小 */272 a[1]++;273 }274 /////275 pkey = l->v[pot];//假设第一个位置的数就是枢轴的位置276 l->v[0] = pkey;//保留277 while (pot < len) {
/*从表的两端交替地向中间扫描 */278 a[0]++;279 while (pot < len&&l->v[len] >= pkey)//确保右边大于关键数280 --len;281 l->v[pot] = l->v[len];282 a[0]++;283 while (pot < len&&l->v[pot] <= pkey)//确保左边的 数小于关键数284 ++pot;285 l->v[len] = l->v[pot];286 }287 l->v[pot] = l->v[0];288 return pot;//返回关键数的位置289 }290 291 void QSort1(SqList* &l, int pot, int len, int(&a)[2]) {292 int pivot;293 if ((len - pot) > MAX_LENGTH_INSERT_SORT) {294 while (pot < len) {295 pivot = Partiton1(l, pot, len, a);/* 将L->r[low..high]一分为二,算出枢轴值pivot */296 QSort1(l, pot, pivot - 1, a);/* 对低子表递归排序 */297 pot = pivot + 1;//尾递归298 }299 }300 else301 InsertSort(l,a);302 }303 304 void QuickSort1(SqList* &l, int(&a)[2]) {305 QSort1(l, 1, l->len, a);306 }307 308 309 /*************************************************************/310 int T036(){311 /* int d[N]={9,1,5,8,3,7,4,6,2}; */312 int d[N] = { 50,10,90,30,70,40,80,60,20 };313 /* int d[N]={9,8,7,6,5,4,3,2,1}; */314 int count[2] = { 0,0 };//记录比较次数和交换次数315 SqList *l0, *l1, *l2, *l3, *l4, *l5, *l6, *l7, *l8, *l9, *l10;316 317 l0 = new SqList;318 for (int i = 0; i < N; i++)319 l0->v[i + 1] = d[i];320 l0->len = N;321 322 l1 = l2 = l3 = l4 = l5 = l6 = l7 = l8 = l9 = l10 = l0;323 printf("排序前:\n");324 for(int i=1;i<=N;++i)325 cout << l0->v[i] << " ";326 cout << endl;327 328 printf("初级冒泡排序:\n");329 BubbleSort0(l0,count);330 for (int i = 1; i <= N; ++i)331 cout << l0->v[i] << " ";332 cout << endl;333 cout << "比较次数: " << count[0] << " ; 交换次数: " << count[1] << endl;334 count[0] = count[1] = 0;//归0335 336 printf("冒泡排序:\n");337 BubbleSort(l1,count);338 for (int i = 1; i <= N; ++i)339 cout << l1->v[i] << " ";340 cout << endl;341 cout << "比较次数: " << count[0] << " ; 交换次数: " << count[1] << endl;342 count[0] = count[1] = 0;//归0343 344 printf("改进冒泡排序:\n");345 BubbleSort2(l2,count);346 for (int i = 1; i <= N; ++i)347 cout << l2->v[i] << " ";348 cout << endl;349 cout << "比较次数: " << count[0] << " ; 交换次数: " << count[1] << endl;350 count[0] = count[1] = 0;//归0351 352 printf("选择排序:\n");353 SelectSort(l3,count);354 for (int i = 1; i <= N; ++i)355 cout << l3->v[i] << " ";356 cout << endl;357 cout << "比较次数: " << count[0] << " ; 交换次数: " << count[1] << endl;358 count[0] = count[1] = 0;//归0359 360 printf("直接插入排序:\n");361 InsertSort(l4, count);362 for (int i = 1; i <= N; ++i)363 cout << l4->v[i] << " ";364 cout << endl;365 cout << "比较次数: " << count[0] << " ; 交换次数: " << count[1] << endl;366 count[0] = count[1] = 0;//归0367 368 printf("希尔排序:\n");369 ShellSort(l5, count);370 for (int i = 1; i <= N; ++i)371 cout << l5->v[i] << " ";372 cout << endl;373 cout << "比较次数: " << count[0] << " ; 交换次数: " << count[1] << endl;374 count[0] = count[1] = 0;//归0375 376 printf("堆排序:\n");377 HeapSort(l6, count);378 for (int i = 1; i <= N; ++i)379 cout << l6->v[i] << " ";380 cout << endl;381 cout << "比较次数: " << count[0] << " ; 交换次数: " << count[1] << endl;382 count[0] = count[1] = 0;//归0383 384 printf("归并排序(递归):\n");385 MergeSort(l7, count);386 for (int i = 1; i <= N; ++i)387 cout << l7->v[i] << " ";388 cout << endl;389 cout << "比较次数: " << count[0] << " ; 交换次数: " << count[1] << endl;390 count[0] = count[1] = 0;//归0391 392 printf("归并排序(非递归):\n");393 MergeSort2(l8, count);394 for (int i = 1; i <= N; ++i)395 cout << l8->v[i] << " ";396 cout << endl;397 cout << "比较次数: " << count[0] << " ; 交换次数: " << count[1] << endl;398 count[0] = count[1] = 0;//归0399 400 printf("快速排序:\n");401 QuickSort(l9, count);402 for (int i = 1; i <= N; ++i)403 cout << l9->v[i] << " ";404 cout << endl;405 cout << "比较次数: " << count[0] << " ; 交换次数: " << count[1] << endl;406 count[0] = count[1] = 0;//归0407 408 printf("改进快速排序:\n");409 QuickSort1(l10, count);410 for (int i = 1; i <= N; ++i)411 cout << l10->v[i] << " ";412 cout << endl;413 cout << "比较次数: " << count[0] << " ; 交换次数: " << count[1] << endl;414 count[0] = count[1] = 0;//归0415 416 417 /*大数据排序*/418 /*419 srand(time(0));420 int Max=10000;421 int d[10000];422 int i;423 SqList l0;424 for(i=0;i

 

转载于:https://www.cnblogs.com/zzw1024/p/10598037.html

你可能感兴趣的文章
OpenCV 入门
查看>>
css 3D transform变换
查看>>
ele表格合并行之后的selection选中
查看>>
正则表达式分解剖析(一文悟透正则表达式)
查看>>
解决UILable标点符号居中的问题
查看>>
HTML5新特性教程
查看>>
ImageOptim-无损图片压缩Mac版
查看>>
12 Go语言map底层浅析
查看>>
vue-resumer 项目中 element-ui 遇到的 textarea autosize 问题
查看>>
以主干开发作为持续交付的基础
查看>>
PHP扩展库PEAR被攻击,近半年下载者或被影响
查看>>
传统运维团队转型应该注意哪些问题?
查看>>
JavaScript函数(二)
查看>>
Airbnb改进部署管道安全性,规范部署顺序
查看>>
腾讯最大规模裁撤中层干部,让贤年轻人
查看>>
当我们谈性能的时候,我们实际上在谈什么?
查看>>
蔡超:入门 Go 语言必须跨越的五个思维误区
查看>>
使用Akka Actor和Java 8构建反应式应用
查看>>
curl常用命令详解
查看>>
saltstack 添加计划任务
查看>>