商业网站的建设与维护,wordpress用redis,免费网站视频主持人,网址大全怎么卸载排序 排序的概念常见的排序算法常见排序算法的实现数组的打印 插入排序直接插入排序的实现希尔排序( 缩小增量排序 )希尔排序的实现 交换排序冒泡排序冒泡排序的实现选择排序选择排序的实现堆排序堆排序的实现快速排序快速排序非递归 归并排序归并排序的递归实现归并排序的非递… 排序 排序的概念常见的排序算法常见排序算法的实现数组的打印 插入排序直接插入排序的实现希尔排序( 缩小增量排序 )希尔排序的实现 交换排序冒泡排序冒泡排序的实现选择排序选择排序的实现堆排序堆排序的实现快速排序快速排序非递归 归并排序归并排序的递归实现归并排序的非递归实现 计数排序计数排序的实现 排序算法复杂度及稳定性分析排序算法的测试主函数 排序的概念 排序所谓排序就是使一串记录按照其中的某个或某些关键字的大小递增或递减的排列起来的操作。 稳定性假定在待排序的记录序列中存在多个具有相同的关键字的记录若经过排序这些记录的相对次序保持不变即在原序列中r[i]r[j]且r[i]在r[j]之前而在排序后的序列中r[i]仍在r[j]之前则称这种排序算法是稳定的否则称为不稳定的。 内部排序数据元素全部放在内存中的排序。 外部排序数据元素太多不能同时放在内存中根据排序过程的要求不能在内外存之间移动数据的排序。 常见的排序算法 插入排序直接插入排序、希尔排序。 选择排序选择排序、堆排序。 交换排序冒泡排序、快速排序。 归并排序归并排序。 常见排序算法的实现 void PrintArray(int* a, int n);void InsertSort(int* a, int n);void ShellSort(int* a, int n);void BubbleSort(int* a, int n);void SelectSort(int* a, int n);void HeapSort(int* a, int n);void QuickSort(int* a, int begin, int end);数组的打印 void PrintArray(int* a, int n) {for (int i 0; i n; i){printf(%d , a[i]);}printf(\n); }插入排序 直接插入排序是一种简单的插入排序法其基本思想是把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中直到所有的记录插入完为止得到一个新的有序序列 。实际中我们玩扑克牌时就用了插入排序的思想。当插入第i(i1)个元素时前面的array[0],array[1],…,array[i-1]已经排好序此时用array[i]的排序码与array[i-1],array[i-2],…的排序码顺序进行比较找到插入位置即将array[i]插入原来位置上的元素顺序后移。 直接插入排序的特性总结 元素集合越接近有序直接插入排序算法的时间效率越高。时间复杂度O(N^2)。空间复杂度O(1)它是一种稳定的排序算法。稳定性稳定。 直接插入排序的实现 将数组end位置的值跟tmp的值比较如果a[end]的值大于tmp的值就将end位置的值往后面挪一个否则就将tmp的值插入到end位置的后面一个。以此类推完成tmp值的插入。 void InsertSort(int* a, int n) {for (int i 1; i n; i){//[0,end]有序插入tmp依旧有序int end i - 1;int tmp a[i];while (end 0){if (a[end] tmp){a[end 1] a[end];--end;}else{break;}}a[end 1] tmp;} }希尔排序( 缩小增量排序 ) 希尔排序法又称缩小增量法。希尔排序法的基本思想是先选定一个整数把待排序文件中所有记录分成个组所有距离为的记录分在同一组内并对每一组内的记录进行排序。然后取重复上述分组和排序的工作。当到达1时所有记录在统一组内排好序。 希尔排序的特性总结 希尔排序是对直接插入排序的优化。当gap 1时都是预排序目的是让数组更接近于有序。当gap 1时数组已经接近有序的了这样就会很快。这样整体而言可以达到优化的效果。我们实现后可以进行性能测试的对比。希尔排序的时间复杂度不好计算因为gap的取值方法很多导致很难去计算因此在好些树中给出的希尔排序的时间复杂度都不固定。 希尔排序的实现 gap越大大的数可以更快的到后面小的数可以更快的到前面越不接近有序。gap越小大的数挪动越慢但是他越接近有序。gap1就是直接插入排序。 void ShellSort(int* a, int n) {//1.gap1 预排序//2.gap1 直接插入排序int gap n;while (gap 1){//gap gap / 3 1; //1可以保证最后一次一定是1gap gap / 2;//一组一组排先排红色一组再排蓝色一组再排绿色一组//for (int j 0; j gap; j) //循环gap//{// for (int i j; i n - gap; i gap) //每组数据插入排序// {// int end i;// int tmp a[end gap];// while (end 0)// {// if (a[end] tmp)// {// a[end gap] a[end];// end - gap;// }// else// {// break;// }// }// a[end gap] tmp;// }//}//多组并排for (int i 0; i n - gap; i){int end i;int tmp a[end gap];while (end 0){if (a[end] tmp){a[end gap] a[end];end - gap;}else{break;}}a[end gap] tmp;}} }交换排序 基本思想所谓交换就是根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置交换排序的特点是将键值较大的记录向序列的尾部移动键值较小的记录向序列的前部移动。 冒泡排序 冒泡排序的特性总结 冒泡排序是一种非常容易理解的排序。时间复杂度O(N^2)。空间复杂度O(1)。稳定性稳定。 冒泡排序的实现 将相邻两个数进行比较如果前面一个数比后面一个数大就进行交换。一次交换完成最大数的排序以此类推完成所有数的排序。 void BubbleSort(int* a, int n) {for (int j 0; j n; j){bool exchange false;for (int i 1; i n - j; i){if (a[i - 1] a[i]){int tmp a[i];a[i] a[i - 1];a[i - 1] tmp;exchange true;}}if (exchange false){break;}} }选择排序 基本思想每一次从待排序的数据元素中选出最小或最大的一个元素存放在序列的起始位置直到全部待排序的数据元素排完 。 直接选择排序: 1.在元素集合array[i]–array[n-1]中选择关键码最大(小)的数据元素 2.若它不是这组元素中的最后一个(第一个)元素则将它与这组元素中的最后一个第一个元素交换 3.在剩余的array[i]–array[n-2]array[i1]–array[n-1]集合中重复上述步骤直到集合剩余1个元素   直接选择排序的特性总结 直接选择排序思考非常好理解但是效率不是很好。实际中很少使用时间复杂度O(N^2)空间复杂度O(1)稳定性不稳定 选择排序的实现 每次同时选出最小的一个数和最大的一个数完成排序以此类推遍历完数组完成整个数组的排序 void Swap(int* p1, int* p2) {int tmp *p1;*p1 *p2;*p2 tmp; }void SelectSort(int* a, int n) {int begin 0, end n - 1;while (begin end){int maxi begin, mini begin;for (int i begin; i end; i){if (a[i] a[maxi]){maxi i;}if (a[i] a[mini]){mini i;}}Swap(a[begin], a[mini]);//如果maxi和begin重叠修正一下即可if (begin maxi){maxi mini;}Swap(a[end], a[maxi]);begin;--end;} }堆排序 堆排序(Heapsort)是指利用堆积树堆这种数据结构所设计的一种排序算法它是选择排序的一种。它是通过堆来进行选择数据。需要注意的是排升序要建大堆排降序建小堆。 堆排序的特性总结 堆排序使用堆来选数效率就高了很多。时间复杂度O(N*logN)空间复杂度O(1)稳定性不稳定 堆排序的实现 void AdjustDown(int* a, int n,int parent) {int child parent * 2 1;while (child n){//找出小的那个孩子if (child 1 n a[child 1] a[child]){child;}if (a[child] a[parent]){Swap(a[child], a[parent]);parent child;child parent * 2 1;}else{break;}} }//排升序 void HeapSort(int* a, int n) {//建堆for (int i (n - 1 - 1) / 2; i 0; --i){AdjustDown(a, n, i);}int end n - 1;while (end 0){Swap(a[0], a[end]);AdjustDown(a, end, 0);--end;} }快速排序 快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法其基本思想为任取待排序元素序列中的某元素作为基准值按照该排序码将待排序集合分割成两子序列左子序列中所有元素均小于基准值右子序列中所有元素均大于基准值然后最左右子序列重复该过程直到所有元素都排列在相应位置上为止。 将区间按照基准值划分为左右两半部分的常见方式有 1. hoare版本   首先将keyi的定义为左边的值然后右边从右往左找小左边从左往右找大进行交换最后将keyi的值和left位置的值进行交换以此类推完成所有数据的交换。 1.左边做key右边先走保障了相遇位置的值比key小 2.右边做key左边先走保障了相遇位置的值比key大 L和R相遇无非就是两种情况L遇R和R遇L 情况一L遇RR是停下来的L在走R先走R停下来的位置一定比key小相遇的位置就是R停下来的位置就一定比key要小。 情况二R遇L在相遇这一轮L就没动R在移动跟L相遇相遇位置就是L的位置L的位置就是key的位置or交换过一些轮次相遇L位置一定比key小。 int PartSort1(int* a, int left, int right) {int keyi left;while (left right){//右边找小while (left right a[right] a[keyi]){--right;}//左边找大while (left right a[left] a[keyi]){left;}Swap(a[left], a[right]);}Swap(a[keyi], a[left]);return left; }void QuickSort(int* a, int begin,int end) {if (begin end)return;int keyi PartSort1(a, begin, end);//[begin,keyi-1] keyi [keyi1,end]QuickSort(a, begin, keyi - 1);QuickSort(a, keyi1, end); }2. 挖坑法   将left位置的值赋值作为key的值再将left的值作为hole的值。右边找小将这个值放在hole的位置再将原来右边的位置作为新的hole。左边找大将这个值放在新的hole的位置再将left的位置作为新的hole。以此类推完成整个数据的排序。 int PartSort2(int* a, int left, int right) {int key a[left];int hole left;while (left right){//右边找小while (left right a[right] key){--right;}a[hole] a[right];hole right;//左边找大while (left right a[left] key){left;} a[hole] a[left];hole left;}a[hole] key;return hole; }void QuickSort2(int* a, int begin, int end) {if (begin end)return;int keyi PartSort2(a, begin, end);//[begin,keyi-1] keyi [keyi1,end]QuickSort2(a, begin, keyi - 1);QuickSort2(a, keyi 1, end); }3. 前后指针版本   基本思想cur找小a[cur]keyprev交换prev位置和cur位置的值。 1.一开始prev和cur是相邻的。 2.当cur遇到比key大的值以后他们之间的值都是比key大的值。 3.cur找小找到小的以后跟prev位置的值交换相当于把大的值翻滚式往右边推同时把小的值换到左边。 int PartSort3(int* a, int left, int right) {int prev left;int cur left 1;int keyi left;while (cur right){if (a[cur] a[keyi]prev!cur){//prev;Swap(a[prev], a[cur]);}cur;}Swap(a[prev], a[keyi]);keyi prev;return keyi; }void QuickSort3(int* a, int begin, int end) {if (begin end)return;int keyi PartSort3(a, begin, end);//[begin,keyi-1] keyi [keyi1,end]QuickSort3(a, begin, keyi - 1);QuickSort3(a, keyi 1, end); }快速排序优化 三数取中法选key int GetMidIndex(int* a, int left, int right) {int mid (left right) / 2;if (a[left] a[mid]){if (a[mid] a[right]){return mid;}else if (a[left] a[right]){return right;}else{return left;}}else // a[left] a[mid]{if (a[mid] a[right]){return mid;}else if (a[left] a[right]){return right;}else{return left;}} }优化后的hoare版本其他两种方法类似 int PartSort1(int* a, int left, int right) {int midi GetMidIndex(a, left, right);Swap(a[left], a[midi]);int keyi left;while (left right){//右边找小while (left right a[right] a[keyi]){--right;}//左边找大while (left right a[left] a[keyi]){left;}Swap(a[left], a[right]);}Swap(a[keyi], a[left]);return left; }void QuickSort(int* a, int begin,int end) {if (begin end)return;int keyi PartSort1(a, begin, end);//[begin,keyi-1] keyi [keyi1,end]QuickSort(a, begin, keyi - 1);QuickSort(a, keyi1, end); }快速排序非递归 利用栈来实现快速排序的非递归先处理左半边的区间再处理右半边的区间 void QuickSortNonR(int* a, int begin, int end) {ST st;STInit(st);STPush(st,end);STPush(st, begin);while (!STEmpty(st)){int left STTop(st);STPop(st);int right STTop(st);STPop(st);int keyi PartSort1(a, left, right);if (keyi 1 right){STPush(st, right);STPush(st, keyi 1);}if (left keyi - 1){STPush(st, keyi - 1);STPush(st, left);}}STDestroy(st); }快速排序的特性总结 快速排序整体的综合性能和使用场景都是比较好的所以才敢叫快速排序。时间复杂度O(N*logN)。空间复杂度O(logN)。稳定性不稳定。 归并排序 基本思想归并排序MERGE-SORT是建立在归并操作上的一种有效的排序算法,该算法是采用分治法Divide and Conquer的一个非常典型的应用。将已有序的子序列合并得到完全有序的序列即先使每个子序列有序再使子序列段间有序。若将两个有序表合并成一个有序表称为二路归并。 归并排序核心步骤 归并排序的递归实现 void _MergeSort(int* a, int begin, int end, int* tmp) {if (begin end)return;int mid (begin end) / 2;//[begin,mid] [mid1,end]_MergeSort(a, begin, mid, tmp);_MergeSort(a, mid1, end, tmp);int begin1 begin, end1 mid;int begin2 mid 1, end2 end;int i begin;while (begin1 end1 begin2 end2){if (a[begin1] a[begin2]){tmp[i] a[begin1];}else{tmp[i] a[begin2];}}while (begin1 end1){tmp[i] a[begin1];}while (begin2 end2){tmp[i] a[begin2];}memcpy(abegin, tmpbegin, sizeof(int) * (end - begin 1)); }void MergeSort(int* a, int n) {int* tmp (int*)malloc(sizeof(int) * n);_MergeSort(a, 0, n - 1, tmp);free(tmp); }归并排序的非递归实现 利用gap124…则可能造成越界需要额外进行处理 有以下三种情况 1.end1 begin2 end2全部越界 2.begin2 end2越界 3.end2越界 为了解决上述问题第一种方法是归并一组拷贝一组 void MergeSortNonR(int* a, int n) {int* tmp (int*)malloc(sizeof(int) * n);//1 2 4...int gap 1;while (gapn){int j 0;for (int i 0; i n; i 2 * gap){//每组的合并数据int begin1 i, end1 i gap - 1;int begin2 i gap, end2 i 2 * gap - 1;printf([%d,%d][%d,%d]\n, begin1, end1, begin2, end2);if (end1 n || begin2 n){break;}//修正if (end2 n){end2 n - 1;}while (begin1 end1 begin2 end2){if (a[begin1] a[begin2]){tmp[j] a[begin1];}else{tmp[j] a[begin2];}}while (begin1 end1){tmp[j] a[begin1];}while (begin2 end2){tmp[j] a[begin2];}//归并一组拷贝一组memcpy(a i, tmp i, sizeof(int) * (end2 - i 1));}printf(\n);//memcpy(a, tmp, sizeof(int) * n);gap * 2;}free(tmp); }第二种方法是分别考虑三种越界的情况完成整个数组的拷贝 void MergeSortNonR(int* a, int n) {int* tmp (int*)malloc(sizeof(int) * n);//1 2 4...int gap 1;while (gap n){int j 0;for (int i 0; i n; i 2 * gap){//每组的合并数据int begin1 i, end1 i gap - 1;int begin2 i gap, end2 i 2 * gap - 1;printf(修正前[%d,%d][%d,%d]\n, begin1, end1, begin2, end2);if (end1 n){end1 n - 1;//不存在区间begin2 n;end2 n - 1;}else if (begin2 n){//不存在区间begin2 n;end2 n - 1;}else if (end2 n){end2 n - 1;}printf(修正后[%d,%d][%d,%d]\n, begin1, end1, begin2, end2);while (begin1 end1 begin2 end2){if (a[begin1] a[begin2]){tmp[j] a[begin1];}else{tmp[j] a[begin2];}}while (begin1 end1){tmp[j] a[begin1];}while (begin2 end2){tmp[j] a[begin2];}}printf(\n);memcpy(a, tmp, sizeof(int) * n);gap * 2;}free(tmp); }归并排序的特性总结 归并的缺点在于需要O(N)的空间复杂度归并排序的思考更多的是解决在磁盘中的外排序问题。时间复杂度O(N*logN)空间复杂度O(N)稳定性稳定 内排序在内存中对数据排序 数据量小 外排序再外存硬盘中对数据排序数据量大 计数排序 思想计数排序又称为鸽巢原理是对哈希直接定址法的变形应用。 操作步骤 统计相同元素出现次数根据统计的结果将序列回收到原来的序列中 计数排序的实现 遍历数组找到最大值和最小值确定最小值与最大值之间的差值范围来开辟新数组对每个数据出现的次数进行统计。最后按照从小到大和统计的次数完成数据的排序 //时间复杂度ONRange //空间复杂度:O(Range) //缺陷1依赖数据范围适用于范围集中的数组 //缺陷2只能用于整形 void CountSort(int* a, int n) {int min a[0], max a[0];for (int i 0; i n; i){if (a[i] min){min a[i];}if (a[i] max){max a[i];}}int range max - min 1;int* countA (int*)malloc(sizeof(int) * range);memset(countA, 0, sizeof(int) * range);//统计次数for (int i 0; i n; i){countA[a[i] - min];}//排序int k 0;for (int j 0; j range; j){while (countA[j]--){a[k] j min;}} }计数排序的特性总结 计数排序在数据范围集中时效率很高但是适用范围及场景有限。时间复杂度O(MAX(N,范围))空间复杂度O(范围)稳定性稳定 排序算法复杂度及稳定性分析 稳定性假定再待排序的记录序列中存在多个具有相同的关键字的记录若经过排序这些记录的相对次序保持不变即在原序列中r[i]r[j]且r[i]在r[j]之前而在排序后的序列中r[i]仍在r[j]之前则称这种排序算法是稳定的否则称为不稳定的。 常见算法的稳定性 排序算法的测试主函数 void TestInsertSort() {int a[] { 4,7,1,9,3,4,5,8,3,2 };PrintArray(a, sizeof(a) / sizeof(int));InsertSort(a, sizeof(a) / sizeof(int));PrintArray(a, sizeof(a) / sizeof(int)); }void TestShellSort() {int a[] { 4,7,1,9,3,4,5,8,3,2 };PrintArray(a, sizeof(a) / sizeof(int));InsertSort(a, sizeof(a) / sizeof(int));PrintArray(a, sizeof(a) / sizeof(int));ShellSort(a, sizeof(a) / sizeof(int));PrintArray(a, sizeof(a) / sizeof(int)); }//void TestQuickSort() //{ // int a[] { 4,7,1,9,3,4,5,8,3,2 }; // PrintArray(a, sizeof(a) / sizeof(int)); // QuickSort(a, 0,sizeof(a) / sizeof(int)-1); // PrintArray(a, sizeof(a) / sizeof(int)); //}//void TestQuickSort() //{ // int a[] { 4,7,1,9,3,4,5,8,3,2 }; // PrintArray(a, sizeof(a) / sizeof(int)); // QuickSort2(a, 0, sizeof(a) / sizeof(int) - 1); // PrintArray(a, sizeof(a) / sizeof(int)); //}void TestQuickSort() {int a[] { 4,7,1,9,3,4,5,8,3,2 };PrintArray(a, sizeof(a) / sizeof(int));QuickSort3(a, 0, sizeof(a) / sizeof(int) - 1);PrintArray(a, sizeof(a) / sizeof(int)); }void TestMergeSort() {int a[] { 4,7,1,9,3,4,5,8,3,2 };PrintArray(a, sizeof(a) / sizeof(int));MergeSort(a, sizeof(a) / sizeof(int));PrintArray(a, sizeof(a) / sizeof(int)); }void TestMergeSortNonR() {int a[] { 4,7,1,9,3,4,5,8,3,2 };PrintArray(a, sizeof(a) / sizeof(int));MergeSortNonR(a, sizeof(a) / sizeof(int));PrintArray(a, sizeof(a) / sizeof(int)); }int main() {//TestInsertSort();//TestShellSort();//TestQuickSort();//TestMergeSort();TestMergeSortNonR();return 0; }