网站开发 站长统计,重庆seo优化公司,硚口区建设局网站,手机wordpress无法评论目录 1.排序的概念及其运用 1.1排序的概念 1.2排序运用 1.3常见的排序算法 2.插入排序 2.1 原理演示#xff1a;编辑 2.2 算法实现 2.3 算法的时间复杂度和空间复杂度分析 3.希尔排序 3.1算法思想 3.2原理演示 3.3代码实现 3.4希尔算法的时间复杂度 4.冒泡排序 4.1冒泡排… 目录 1.排序的概念及其运用 1.1排序的概念 1.2排序运用 1.3常见的排序算法 2.插入排序 2.1 原理演示编辑 2.2 算法实现 2.3 算法的时间复杂度和空间复杂度分析 3.希尔排序 3.1算法思想 3.2原理演示 3.3代码实现 3.4希尔算法的时间复杂度 4.冒泡排序 4.1冒泡排序原理图解 4.2.冒泡排序实现 4.3冒泡排序封装为函数 4.4 冒泡排序代码效率改进。 5.堆排序 5.1升序建大堆降序建小堆 5.2 建堆的时间复杂度 5.2.1 向下调整建堆 5.2.2向上调整建堆 5.3 排序实现 6.选择排序 6.1基本思想 6.2算法演示 6.3代码实现 6.4时间复杂度分析 7.快速排序 7.1 hoare版本 7.1.1算法图解 7.1.2代码实现 7.1.3 算法优化---三数取中 7.2挖坑法快排 7.2.1算法图解 7.2.2 代码实现 7.3 前后指针法 7.4快速排序进一步优化 7.5快速排序非递归写法 8.归并排序 9.计数排序 10.结语 深度优先遍历 dfs : 先往深处走走到没有了再往回前序遍历 一般是递归 广度优先遍历 bfs 层序遍历 一般用队列 1.排序的概念及其运用
1.1排序的概念 排序所谓排序就是使一串记录按照其中的某个或某些关键字的大小递增或递减的排列起来的操作。 稳定性假定在待排序的记录序列中存在多个具有相同的关键字的记录若经过排序这些记录的相对次 序保持不变即在原序列中r[i]r[j]且r[i]在r[j]之前而在排序后的序列中r[i]仍在r[j]之前则称这种排 序算法是稳定的否则称为不稳定的。 内部排序数据元素全部放在内存中的排序。 外部排序数据元素太多不能同时放在内存中根据排序过程的要求不能在内外存之间移动数据的排序。 1.2排序运用 1.3常见的排序算法 2.插入排序 直接插入排序是一种简单的插入排序法 算法思想 把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中直到所有的记录插入完为 止得到一个新的有序序列 。 和我们玩扑克牌整理牌的时候是非常相像的 将我们的摸到的牌作为手里的牌的最后一张从倒数第一张开始到第一张逐次比较如果当前牌大于前一张就放置在当前位置如果小于那就向前移动最坏的情况就是每次摸到牌都要逐渐比较放到最前面。
2.1 原理演示
2.2 算法实现
由原理图我们知道这个算法的实现就是第二个先和1第一个比较调整位置第三个又和前两个进行比较调整位置。
第一次 调整前两个位置
第二次 调整前三个位置
第三次 调整前四个位置
。。。
n个元素就调整n-1次
每一次调整都是倒数一个与倒数第二个比较调整完倒数第二个又和倒数第三个做比较知道比较到倒数最后一个也就是最开始的一个。
void InserPort(int* a, int n)
{int i 0;for (i 0; i n - 1; i)//n个元素调整n-1次{int end i;int tmp a[end 1];//最后一个元素值给tmpwhile (end 0){if (tmp a[end]){//交换a[end 1] a[end];a[end] tmp;}else{//不动break;}//继续比较调整前两个end--;}}
}2.3 算法的时间复杂度和空间复杂度分析
上述代码就是最坏的情况 时间复杂度为O(N^2)
空间复杂度为O(1) .元素集合越接近有序直接插入排序算法的时间效率越高 3.希尔排序
3.1算法思想 希尔排序法又称缩小增量法。希尔排序法的基本思想是先选定一个整数把待排序文件中所有记录分成个 组所有距离为的记录分在同一组内并对每一组内的记录进行排序。然后取重复上述分组和排序的工作。当间距到达1时所有记录在统一组内排好序。 通俗来讲就是先进行与排序再直接插入排序 预排序的操作是将数据以同一个间隔的数据分为一组使得更大的数更快的到一段更小的数更快到一端。 3.2原理演示 3.3代码实现
ShellSort(int* a, int n)
{int i 0;int gap n;while (gap 1){gap / 2;for (i 0; i n - gap; i){int end i;int tmp a[end gap];while (endgap){if (tmp a[end]){a[end gap] a[end];a[end] tmp;}else{break;}end - gap;}}}
}
3.4希尔算法的时间复杂度 希尔排序的时间复杂度不好计算因为 gap 的取值方法很多导致很难去计算因此在好些树中给出的 希尔排序的时间复杂度都不固定 《数据结构》--严蔚敏 《数据结构-用面相对象方法与C描述》--- 殷人昆 按照
来计算
空间复杂度为O1
稳定性不稳定
4.冒泡排序 核心思想两两相邻的元素相比较是一种交换排序
4.1冒泡排序原理图解 4.2.冒泡排序实现 通过图解原理我们可以发现规律以10个元素排列举例 1.每一趟比较完全完成就把这一趟数据的最大数放在最后第一趟是10个数据中的最大值9在最后第二趟是9个数据中的8在最后那么我们10个元素就要循环9趟那么n个数据就要循环n - 1趟。 2.第一趟是10个数据就有9对数据比较那么第二趟就有8对数据进行比较。如果一趟有n个数据就要比较n - 1对数据。 3.所以需要两层循环外层控制趟数内层控制每一趟要比较的次数。 看如下实现。 int main()
{int len[10] { 0 };int i 0;for (i 0; i 10; i){scanf(%d,len[i]);}int n sizeof(len) / sizeof(len[0]);//printf(%d, n);int x 0;for (x 0; x n; x){int y 0;{for (y 0; y n-1 - x; y){if (len[y] len[y 1]){int temp 0;temp len[y];len[y] len[y 1];len[y 1] temp;//交换}}}}int j 0;for (j 0; j 10; j){printf( %d , len[j]);}
}
运行结果如图大家也可以用源码自己体验一下效果 4.3冒泡排序封装为函数 现在已经实现了冒泡排序为了以后的方便我们来试着将这个冒泡排序模块功能封装为一个函数。让我们一起来看看自定义为函数有那些坑。 按照上述排序规则和封装函数的方法我们将数组作为一个函数参数传递给冒泡排序函数来执行冒泡排序我们来看一下
void BBurd_sort(int arr[10])
{int n sizeof(arr) / sizeof(arr[0]);int x 0;for (x 0; x n; x){int y 0;{for (y 0; y n - 1 - x; y){if (arr[y] arr[y 1]){int temp 0;temp arr[y];arr[y] arr[y 1];arr[y 1] temp;//交换}}}}}
int main()
{int arr[10] { 0 };int i 0;for (i 0; i 10; i){scanf(%d, arr[i]);}//int sz sizeof(arr) / sizeof(arr[0]);BBurd_sort(arr);int j 0;for (j 0; j 10; j){printf( %d , arr[j]);}return 0;
} 我们观察到没有发生排序我们调试看一下 问题所在我们这里想要实现的功能是n 保存的是数组的大小那么应该是10才对为什么是2呢。 思考sizeof(arr[0] 求的是一个整形数组元素的大小那么其大小就应该是4字节 那么说明我们的sizeof(arr)就是8字节那么只有可能我们这里的arr并不是一整个数组而是一个地址 地址也就是指针在32位操作系统下面大小是4个字节64位操作系统下是8个字节那就说明我们这里的arr实质上是一个指针保存的是数组首元素的地址。 所以在函数里面是没有办法求出这个数组的大小解决办法把函数的大小作为一个函数的参数一起传递看一下改进效果。 程序正常实现附上源码。大家体验一下效果。 void BBurd_sort(int arr[10], int n)
{int x 0;for (x 0; x n; x){int y 0;{for (y 0; y n-1 - x; y){if (arr[y] arr[y 1]){int temp 0;temp arr[y];arr[y] arr[y 1];arr[y 1] temp;//交换}}}}}
int main()
{int arr[10] { 0 };int i 0;for (i 0; i 10; i){scanf(%d, arr[i]);}int sz sizeof(arr) / sizeof(arr[0]);BBurd_sort(arr, sz);int j 0;for (j 0; j 10; j){printf( %d , arr[j]);}return 0;
} 4.4 冒泡排序代码效率改进。 思考 对于这样一个有序数列我们如果执行的话我们的自定义函数就还是会跑一遍那么这样实际效率并不高。所以想能不能改进一下我我们的代码。 再次浏览原理图我们不难发现这样一个规律只要数据是乱序一趟下来就会有元素在发生交换。 比如 9 1 2 3 4 5 6 7 8 这样的数据第一趟会有元素交换第二趟就没有。 那么我们可以这样只要某一趟没有交换说明此时我们的数列已经有序了就跳出 只要发生交换就继续。 那么看一下改进代码 void BBurd_sort(int arr[10], int n)
{int x 0;for (x 0; x n; x){int flag 0;int y 0;for (y 0; y n-1 - x; y){if (arr[y] arr[y 1]){int temp 0;temp arr[y];arr[y] arr[y 1];arr[y 1] temp;//交换flag 1;//发生了交换就改变flag}}//执行完一趟就判断一下有没有交换有交换就继续没有交换就直接退出不用排序了if (flag 0){break;}}}
int main()
{int arr[10] { 0 };int i 0;for (i 0; i 10; i){scanf(%d, arr[i]);}int sz sizeof(arr) / sizeof(arr[0]);BBurd_sort(arr, sz);int j 0;for (j 0; j 10; j){printf( %d , arr[j]);}return 0;
}
5.堆排序 堆排序 (Heapsort) 是指利用堆积树堆这种数据结构所设计的一种排序算法它是选择排序的一种。它是 通过堆来进行选择数据。需要注意的是排升序要建大堆排降序建小堆。 使用堆排序前首先要建立堆 使用堆结构对一组数据进行排序,方便对数据进行处理。粗暴办法就是将原数组数据插入堆再取堆数据覆盖这种方法首先得有堆结构其次插入数据就要额外开辟空间。 最好的方式就是直接将原数组或者原来的这组数据变成堆。将原数组直接看成一颗完全二叉树一般都不是堆。那么就要将原数据之间调成堆----建堆 建堆不是插入数据只是使用向上调整的思想。在原有数据上进行更改调换。 5.1升序建大堆降序建小堆 一般我们要利用堆结构将一组数据排成升序就建立大堆 要利用堆结构将一组数据排成降序就建立小堆。 void HeapSort(int* a, int n)
{//对数据进行建堆for (int i 0; i n; i){AdjustUp(a, 1);}//堆排序---向下调整的思想int end n - 1;while (end 0){Swap(a[0], a[end]);AdjustDown(a, end, 0);--end;//让n-1个数据调整成堆选出次小}} 5.2 建堆的时间复杂度 5.2.1 向下调整建堆 讨论最坏的时间复杂度 将下图进行建立一个大堆 实现 void AdjustDown(int* a, int parent, int n)
{int child parent * 2 1;while (child n){if (child 1 n a[child] a[child 1]){child;//找出左右孩子中大的一个1}if (a[child] a[parent]){//交换Swap(a[child], a[parent]);parent child;child parent * 2 1;}else{break;}}}
//堆排序//首先将数据建堆//升序建大堆降序建小堆//采用向下调整建堆的方式时间复杂度较小int child n - 1;int parent (child - 1) / 2;while (parent 0){AdjustDown(a, parent, n);parent--;} 假设有h层这里测算的时间复杂度是最坏的情况那么就相当于调整的是一个满二叉树的堆。 第h层 共有2^(h-1)个节点 需要调整0次 第h-1层共有2^(h-2)个节点 每个节点调整一次调整2^(h-2)*1次 第h-2层共有2^(h-3)个节点每个节点最坏向下调整两次调整2^(h-3)*2次 第3层共有2^2个节点每个节点向下调整h-3次调整2^2*h-3次 第2层共有2^1个节点每个节点向下调整h-2次调整2^1*h-2次 第1层共有2^0个节点每个节点向下调整h-1次调整2^0*h-1次 时间复杂度为 T(h) 2^0*h-12^1*h-22^2*h-3…………2^(h-3)*22^(h-2)*1① 2T(h) 2^1*h-12^2*h-22^3*h-3…………2^(h-2)*22^(h-1)*1 ② ②-①得 T(h) 2^12^2……2^(h-2)2^(h-1)1-h 2^02^12^2……2^(h-2)2^(h-1)-h 2^h-1-h 由于h是树的层高与节点个数的关系是N 2^h-1 h log(n1) 所以时间复杂度为 O(N) N-longN1~O(N) 5.2.2向上调整建堆 假设有h层这里测算的时间复杂度是最坏的情况那么就相当于调整的是一个满二叉树的堆。 第2层共有2^1个节点每个节点向上调整1次 第3层共有2^2个节点每个节点向上调整2次 第h-2层共有2^(h-3)个节点每个节点向上调整h-3次 第h-1层共有2^(h-2)个节点每个节点向上调整h-2次 第h层 共有2^(h-1)个节点每个节点向上调整h-1次 时间复杂度为T(h) 2^1*12^2*22^3*3……2^(h-3)*(h-3)2^(h-2)*(h-2)2^(h-1)*(h-1) 2 T(h) 2^2*12^3*22^4*3……2^(h-2)*(h-3)2^(h-1)*(h-2)2^(h)*(h-1) T(h) -2-2^22^32^4…………2^(h-1)2^h(h-1) -(2^02^12^2…………2^(h-1))2^h(h-1)2^0 2^h*(h-2)2 由于h是树的层高与节点个数的关系是N 2^h-1 h log(n1) T(N) (N1)log(N1)-2N-1 5.3 排序实现 排序和删除的原理是一样的先找最大/最小然后次大/次小每次选取数据后不会将后面数据覆盖上来否则就会导致关系全乱可能次大数据就要重新建堆增加了工作量了。而是通过堆顶元素和最后一个数据交换位置过后向下调整思想将排除刚刚调整的尾部最大数据除外的剩下数据看成堆循环排序。 最后发现大堆这样处理的数据最大的数据在最后最小的在最前小堆相反。 void AdjustDown(int* a, int parent, int n)
{int child parent * 2 1;while (child n){if (child 1 n a[child] a[child 1]){child;//找出左右孩子中大的一个1}if (a[child] a[parent]){//交换Swap(a[child], a[parent]);parent child;child parent * 2 1;}else{break;}}}
//堆排序void HeapSort(int* a, int n)
{//首先将数据建堆//升序建大堆降序建小堆//采用向下调整建堆的方式时间复杂度较小int child n - 1;int parent (child - 1) / 2;while (parent 0){AdjustDown(a, parent, n);parent--;}//排序int end n - 1;while (end 0){Swap(a[0], a[end]);AdjustDown(a, 0, end);end--;}}
6.选择排序 6.1基本思想 每一次从待排序的数据元素中选出最小或最大的一个元素存放在序列的起始位置直到全部待排序的 数据元素排完 。也可第一轮将最小的放在一端将最大的放在一端第二轮选出次大次小。 6.2算法演示 6.3代码实现
//选择排序void SelectSort(int* a, int n)
{int begin 0;int end n - 1;while (begin end){int min begin;int max begin;int i 0;for (i begin1; i end; i){if (a[min] a[i]){min i;}if (a[max] a[i]){max i;}}Swap(a[begin], a[min]);if (begin max){max min;}Swap(a[end], a[max]);end--;begin;}}6.4时间复杂度分析 . 时间复杂度 O(N^2) 如果有10个数据 10 9 8 7 6 5 4 3 2 1 第一次比较2n-1次 第二次比较2n-3次 最后一次比较1次 总共比较n/2次时间复杂度为1/4n^2 3. 空间复杂度O(1) 4. 稳定性不稳定 7.快速排序
算法思想 快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法其基本思想为任取待排序元素序列中 的某元素作为基准值按照该排序码将待排序集合分割成两子序列左子序列中所有元素均小于基准值右 子序列中所有元素均大于基准值然后最左右子序列重复该过程直到所有元素都排列在相应位置上为止。 7.1 hoare版本
单趟
7.1.1算法图解 为什么相遇的位置一定是比k值小的值是因为右边先走那么每次左边停下来的值经过交换一定是比k值大此时r继续走找到比k值大的数才会停下来所以如果右边先走停下来的地方值一定小于k如果左边先走停下来的地方的值一定大于k。
将上述过程递归就可以得到一个有序的序列 7.1.2代码实现
int Partsort(int* a, int left, int right)
{int keyi left;while (left right){while (left right a[right] a[keyi]){right--;//如果左右两边同时是key此时如果不取等号就回陷入死循环//再次判断leftkey是因为值都比k大或者都比k小的极端情况出现越界问题因为外层循环只判断了一次里面的--的循环没有判断}while (left right a[left] a[keyi]){left;}Swap(a[left], a[right]);}Swap(a[left], a[keyi]);return left;
}//快速排序
void QuickSort(int* a, int left,int right)
{if (left right){//大于为空等于只有一个值return;}int keyi Partsort(a, left, right);QuickSort(a, left, keyi - 1);QuickSort(a, keyi 1, right);
}
7.1.3 算法优化---三数取中 为了保证我们快排的效率呢我们试着调整一下我们选择key值的策略。
每次选取三个数中中间值的一个作为我们的key并且将这个值换到数组的最左边 int GetMid(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 left;}else{return right;}}else{if (a[mid a[right]]){return mid;}else if (a[left] a[right])//mid是最小的{return left;}else{return right;}}
}
int Partsort(int* a, int left, int right)
{int mid GetMid(a, left, right);Swap(a[left], a[mid]);int keyi left;while (left right){while (left right a[right] a[keyi]){right--;//如果左右两边同时是key此时如果不取等号就回陷入死循环//再次判断leftkey是因为值都比k大或者都比k小的极端情况出现越界问题因为外层循环只判断了一次里面的--的循环没有判断}while (left right a[left] a[keyi]){left;}Swap(a[left], a[right]);}Swap(a[left], a[keyi]);return left;
}//快速排序
void QuickSort(int* a, int left,int right)
{if (left right){//大于为空等于只有一个值return;}int keyi Partsort(a, left, right);QuickSort(a, left, keyi - 1);QuickSort(a, keyi 1, right);
}
这样我们的逆序排序这种对于快排最坏的情况就变成最好的情况十万个数据1毫秒就可以排好。
7.2挖坑法快排
7.2.1算法图解 7.2.2 代码实现 //挖坑法
int Partsort2(int* a, int left, int right)
{int mid GetMid(a, left, right);Swap(a[left], a[mid]);int ken a[left];int hole left;while (left right){while (left right a[right] ken){right--;}a[hole] a[right];hole right;while (left right a[left] a[ken]){left;}a[hole] a[left];hole left;}a[hole] ken;return hole;}7.3 前后指针法
逻辑cur找比key值小的值然后prev遇到比key值大的就停下来直到cur遇到比key值小的值过后就交换。
prev
在cur没有遇到比key值大的值的时候prev紧紧的跟着cur
在cur遇到比key值大的值的时候prev就停下来了prev在比key大的一组值的前面。 //前后指针
int Partsort3(int* a, int left, int right)
{int mid GetMid(a, left, right);Swap(a[left], a[mid]);int keyi left;int prev left;int cur prev 1;while (cur right){if (a[cur] a[keyi]prev ! cur)//防止开始位置自己跟自己交换{Swap(a[prev], a[cur]);}cur;}Swap(a[prev], a[keyi]);return prev;} 7.4快速排序进一步优化
按照上面的方法实际主题来说大思想就是递归递归是有消耗的而且最后几层的递归往往是最大的如果当递归区间的数值减少到一定程度我们就不递归了特别是到最后一两层的时候那么排序的效率就会有提升。
//快速排序
void QuickSort(int* a, int left,int right)
{if (left right){//大于为空等于只有一个值return;}if ((right - left 1) 10){int keyi Partsort(a, left, right);QuickSort(a, left, keyi - 1);QuickSort(a, keyi 1, right);}else{InserPort(a left, right - left 1);}
}小区间优化编译器对递归优化也比较好小区间不在递归降低递归次数
7.5快速排序非递归写法
使用栈保存每次划分的区间
void QuickSortNonR(int* a, int left, int right)
{
Stack st;
StackInit(st);
StackPush(st, left);
StackPush(st, right);
while (StackEmpty(st) ! 0)
{right StackTop(st);StackPop(st);left StackTop(st);StackPop(st);if(right - left 1)continue;int div PartSort1(a, left, right);// 以基准值为分割点形成左右两部分[left, div) 和 [div1, right)StackPush(st, div1);StackPush(st, right);StackPush(st, left);StackPush(st, div);
}StackDestroy(s);
} 快速排序的特性总结 1. 快速排序整体的综合性能和使用场景都是比较好的所以才敢叫快速排序 2. 时间复杂度O(N*logN) 3. 空间复杂度O(logN) 4. 稳定性不稳定 8.归并排序
8.1排序思想 基本思想 归并排序MERGE-SORT是建立在归并操作上的一种有效的排序算法,该算法是采用分治法Divide and Conquer的一个非常典型的应用。将已有序的子序列合并得到完全有序的序列即先使每个子序列有 序再使子序列段间有序。若将两个有序表合并成一个有序表称为二路归并。 8.2 算法图解 void _MergeSort(int* a, int* tmp,int begin,int end)
{if (end begin){//递归到只有一个或者没有就返回return;}//分割int mid (end begin) / 2;//没有那么均分也不是很影响//然后对左右区间进行递归操作 左区间[begin mid] [mid1,end}_MergeSort(a, tmp, begin, mid);_MergeSort(a, tmp, mid 1, end);//归并到tmp数组里面再拷贝回原数组int begin1 begin, end1 mid;//左区间int begin2 mid 1, end2 end;//右区间int index begin;//tmo数组中的对应位置while (begin end1 begin2 end2)//需要同时将左右两边小的拿出来插入到tmp数组{if (a[begin1] a[begin2]){tmp[index] a[begin1 ];//往后继续找直到一个区间遍历完}else{tmp[index] a[begin2];}}//出循环有一边区间肯定遍历完了但是不确定是那个区间while (begin1 end1){tmp[index] a[begin1];//这种情况是左边区间没有遍历完将后续数据放在这个区间的后面}while (begin2 end2){tmp[index] a[begin2];//这种情况是右边区间没有遍历完将后续数据放在这个区间的后面}//将tmp数组归并回原数组的对应位置所以不一定是从0开始拷贝的memcpy(a begin, tmp begin, (end - begin 1) * sizeof(int));//abegin tmpbegin表示当前区间的起始位置//end -begin1
}
//归并排序
void MergeSort(int* a, int n)
{int* tmp (int*)malloc(sizeof(int) * n);//为归并区间开辟存储数据的数组空间复杂度产生于此if (tmp NULL){perror(malloc);exit(-1);}//区间分割//递归不能每次都开辟空间所以这里分离出子函数_MergeSort(a,tmp, 0, n - 1);free(tmp);tmp NULL;
}
8.3 归并排序非递归实现
//归并排序非递归版本
void MergeSortNonR(int* a, int n)
{int* tmp (int*)malloc(sizeof(int) * n);//为归并区间开辟存储数据的数组空间复杂度产生于此if (tmp NULL){perror(malloc);exit(-1);}int gap 1;while (gap n){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;//[begin1,end][begin2,end2]归并int index i;//tmo数组中的对应位置while (begin1 end1 begin2 end2)//需要同时将左右两边小的拿出来插入到tmp数组{if (a[begin1] a[begin2]){tmp[index] a[begin1];//往后继续找直到一个区间遍历完}else{tmp[index] a[begin2];}}//出循环有一边区间肯定遍历完了但是不确定是那个区间while (begin1 end1){tmp[index] a[begin1];//这种情况是左边区间没有遍历完将后续数据放在这个区间的后面}while (begin2 end2){tmp[index] a[begin2];//这种情况是右边区间没有遍历完将后续数据放在这个区间的后面}//将tmp数组归并回原数组的对应位置所以不一定是从0开始拷贝的memcpy(a i, tmp i, (2 * gap) * sizeof(int));//abegin tmpbegin表示当前区间的起始位置//end -begin1 }gap * 2;}free(tmp);tmp NULL;
} 这个代码当数据为偶数个的时候就会越界 奇数个二二归的时候也会越界需要修正。 8.4归并排序的特性总结 1. 归并的缺点在于需要O(N)的空间复杂度归并排序的思考更多的是解决在磁盘中的外排序问题。 2. 时间复杂度O(N*logN) 3. 空间复杂度O(N) 4. 稳定性稳定 9.计数排序
9.1算法思想 计数排序又称为鸽巢原理是对哈希直接定址法的变形应用。 操作步骤 1. 统计相同元素出现次数 2. 根据统计的结果将序列回收到原来的序列中 9.2 算法演示 代码 //计数排序
void MergeSort(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* count (int*)malloc(sizeof(int) * range);if (count NULL){perror(malloc fail);return;}memset(count, 0, sizeof(int) * range);//统计数据出现的个数for (int i 0; i n; i){count[a[i] - min];}//排序int j 0;for (int i 0; i range; i){while (count[i]--){a[j] i min;}}
}9.3计数排序的特性总结
1. 计数排序在数据范围集中时效率很高但是适用范围及场景有限。 2. 时间复杂度O(MAX(N,范围)) 3. 空间复杂度O(范围) 4. 稳定性稳定
10.结语
以上就是本期所有内容耗时半周应该整理得比较全面越往后面的排序代码实现就越难。知识含量蛮多大家可以配合解释和原码运行理解。创作不易大家如果觉得还可以的话欢迎大家三连有问题的地方欢迎大家指正一起交流学习一起成长我是Nicn正在c方向前行的奋斗者数据结构内容持续更新中感谢大家的关注与喜欢。 文章转载自： http://www.morning.xxwfq.cn.gov.cn.xxwfq.cn http://www.morning.rnqrl.cn.gov.cn.rnqrl.cn http://www.morning.mzskr.cn.gov.cn.mzskr.cn http://www.morning.rlhjg.cn.gov.cn.rlhjg.cn http://www.morning.xqkjp.cn.gov.cn.xqkjp.cn http://www.morning.wkwds.cn.gov.cn.wkwds.cn http://www.morning.chjnb.cn.gov.cn.chjnb.cn http://www.morning.xfncq.cn.gov.cn.xfncq.cn http://www.morning.sdhmn.cn.gov.cn.sdhmn.cn http://www.morning.csdgt.cn.gov.cn.csdgt.cn http://www.morning.vjdofuj.cn.gov.cn.vjdofuj.cn http://www.morning.fyzsq.cn.gov.cn.fyzsq.cn http://www.morning.btsls.cn.gov.cn.btsls.cn http://www.morning.cbnlg.cn.gov.cn.cbnlg.cn http://www.morning.jwtwf.cn.gov.cn.jwtwf.cn http://www.morning.ktfnj.cn.gov.cn.ktfnj.cn http://www.morning.gfznl.cn.gov.cn.gfznl.cn http://www.morning.tcfhs.cn.gov.cn.tcfhs.cn http://www.morning.mpszk.cn.gov.cn.mpszk.cn http://www.morning.rzjfn.cn.gov.cn.rzjfn.cn http://www.morning.wgzzj.cn.gov.cn.wgzzj.cn http://www.morning.lynb.cn.gov.cn.lynb.cn http://www.morning.rfwrn.cn.gov.cn.rfwrn.cn http://www.morning.xnpj.cn.gov.cn.xnpj.cn http://www.morning.jopebe.cn.gov.cn.jopebe.cn http://www.morning.rhjhy.cn.gov.cn.rhjhy.cn http://www.morning.hfxks.cn.gov.cn.hfxks.cn http://www.morning.zbmcz.cn.gov.cn.zbmcz.cn http://www.morning.lzbut.cn.gov.cn.lzbut.cn http://www.morning.wfbnp.cn.gov.cn.wfbnp.cn http://www.morning.lanyee.com.cn.gov.cn.lanyee.com.cn http://www.morning.wckrl.cn.gov.cn.wckrl.cn http://www.morning.krbjb.cn.gov.cn.krbjb.cn http://www.morning.rxnr.cn.gov.cn.rxnr.cn http://www.morning.rfgc.cn.gov.cn.rfgc.cn http://www.morning.qtfss.cn.gov.cn.qtfss.cn http://www.morning.zsleyuan.cn.gov.cn.zsleyuan.cn http://www.morning.gqtw.cn.gov.cn.gqtw.cn http://www.morning.pylpd.cn.gov.cn.pylpd.cn http://www.morning.hkswt.cn.gov.cn.hkswt.cn http://www.morning.skkln.cn.gov.cn.skkln.cn http://www.morning.wxqmc.cn.gov.cn.wxqmc.cn http://www.morning.xysdy.cn.gov.cn.xysdy.cn http://www.morning.qjrjs.cn.gov.cn.qjrjs.cn http://www.morning.gtjkh.cn.gov.cn.gtjkh.cn http://www.morning.srbfp.cn.gov.cn.srbfp.cn http://www.morning.mlycx.cn.gov.cn.mlycx.cn http://www.morning.mingjiangds.com.gov.cn.mingjiangds.com http://www.morning.rgrz.cn.gov.cn.rgrz.cn http://www.morning.mrskk.cn.gov.cn.mrskk.cn http://www.morning.mrgby.cn.gov.cn.mrgby.cn http://www.morning.nxrgl.cn.gov.cn.nxrgl.cn http://www.morning.bhwz.cn.gov.cn.bhwz.cn http://www.morning.lqlhw.cn.gov.cn.lqlhw.cn http://www.morning.dfbeer.com.gov.cn.dfbeer.com http://www.morning.sqqpb.cn.gov.cn.sqqpb.cn http://www.morning.ljwyc.cn.gov.cn.ljwyc.cn http://www.morning.tsnmt.cn.gov.cn.tsnmt.cn http://www.morning.pbbzn.cn.gov.cn.pbbzn.cn http://www.morning.bxch.cn.gov.cn.bxch.cn http://www.morning.ttnfc.cn.gov.cn.ttnfc.cn http://www.morning.ryrgx.cn.gov.cn.ryrgx.cn http://www.morning.tkhyk.cn.gov.cn.tkhyk.cn http://www.morning.nfccq.cn.gov.cn.nfccq.cn http://www.morning.bphqd.cn.gov.cn.bphqd.cn http://www.morning.dxpqd.cn.gov.cn.dxpqd.cn http://www.morning.yunease.com.gov.cn.yunease.com http://www.morning.txzmy.cn.gov.cn.txzmy.cn http://www.morning.woyoua.com.gov.cn.woyoua.com http://www.morning.bklkt.cn.gov.cn.bklkt.cn http://www.morning.dnwlb.cn.gov.cn.dnwlb.cn http://www.morning.ffhlh.cn.gov.cn.ffhlh.cn http://www.morning.iqcge.com.gov.cn.iqcge.com http://www.morning.qgcfb.cn.gov.cn.qgcfb.cn http://www.morning.ypzr.cn.gov.cn.ypzr.cn http://www.morning.vibwp.cn.gov.cn.vibwp.cn http://www.morning.gqmhq.cn.gov.cn.gqmhq.cn http://www.morning.kgtyj.cn.gov.cn.kgtyj.cn http://www.morning.lmqfq.cn.gov.cn.lmqfq.cn http://www.morning.jbxfm.cn.gov.cn.jbxfm.cn
