归并排序（常数空间复杂度的一个变体）

归并排序其他博客已经介绍了很多，这里主要贴一下空间复杂度是O(5)的一个算法设计思路。

归并排序流程

归并排序是不断地将数组分成大小大致相同（偶数相同，奇数左小右大）的子数组，先对子数组进行排序，再进行合并的算法。归并的步骤不需要考虑，空间复杂度是出在合并字串上的，故下面对合并字串进行讨论。

合并字串

为方便叙述，对用到的符号和语言作如下规定：

数组L,R表示左子串和右子串。R[i]语法与python相同。
len为数组长度，lenllen_llenl为左子串长度，lenrlen_rlenr为右子串长度。
合并子串时，我们的左右字串已经是从小到大排列的了，这成为数组的结构。
称交换左右字串最右侧的元素，让整个数组最右侧的元素最小称为右交换；交换左右字串最左侧的元素，让整个数组最右侧的元素最大称为左交换。
以从小到大排序举例。
合并字串可以分为三种情况进行分析：

L[-1] <= R[0]
不用排序。
L[0] >= R[-1]
交换左右字串即可。具体方法（方法1）见下一节。
其他
分别检查交换两侧的情况，选择不破坏结构的方向进行交换。结构不被破坏的充要条件是
A：L[0]<=R[1]orL[n−2]<=R[n−1]A：L[0] <= R[1] or L[n - 2] <= R[n - 1]A：L[0]<=R[1]orL[n−2]<=R[n−1]
即当A成立时进行左交换或右交换即可。当AAA不成立时，则有
Aˉ：L[0]>R[1]andL[n−2]>R[n−1]\bar{A}：L[0] > R[1] and L[n-2] > R[n - 1]Aˉ：L[0]>R[1]andL[n−2]>R[n−1]
成立。
考察把左右子串交换位置¹，得到：
A′：R[0]>L[1]andR[n−2]>L[n−1]A'：R[0] > L[1] and R[n-2] > L[n-1]A′：R[0]>L[1]andR[n−2]>L[n−1]
此时发现AAA成立。进行右交换即可。

对于情况三，每一次进行交换都会缩短未整理的数组长度。因此，经过有限回合就能调整出有序数组。遗憾的是经过测试，按此方法合并子串的复杂度不是O(n)，对于某些特殊的序列，需要O(2n)或O(3n)的复杂度才能得到有序数组。后面有时间会分析这种情况。

用到的方法

方法1

本节介绍一个空间复杂度为O(3)交换左右子串的方法。
注：本方法只能用于左右子串长度相等，或右串长度等于左串长度 + 1。因为归并算法保证左右子串长度相等，或右串长度等于左串长度 + 1，所以这个方法可以放心得在归并中使用。
定义简单指针跳转数列：
p0=0pi+i={pi+lenr,pi<lenlpi−lenl,pi>=lenlp_0 = 0\\ p_{i+i} = \left\{\begin{matrix} p_i + len_r ,p_i < len_l \\ p_i - len_l ,p_i >= len_l \end{matrix}\right. p0=0pi+i={pi+lenr,pi<lenlpi−lenl,pi>=lenl
该数列的使用方法是从i=0i = 0i=0开始，将索引为pip_ipi的元素移动到pi+1p_{i+1}pi+1处，到i=leni = leni=len为止。如对数组[4,5,1,2,3]，lenl=2len_l = 2lenl=2，p={0,3,1,2,4}p = {\{0,3,1,2,4\}}p={0,3,1,2,4}，移动后为[1,2,3,4,5]。

方法2²

^{这就是一个arr_move函数：}

^{void Arr_move_m(int* arr, int len, int dir, int step);
移动数组元素位置。dir > 0 向右移动 step 步，dir < 0 向左移动 step 步，dir = 0 不移动。
消耗空间最少。}

^{这里有一个实现，但是不怎么优雅，抽时间做一个更为优雅简洁的代码。}

^{复杂度分析}

^{经过测试，空间复杂度降低到常数的代价就是计算增加，不过也并没有飞起。

一般复杂度：1.5594929681717247

空间优化复杂度：2.0165047784704986

虽然这个算法的速度比常用的算法慢些，但也是我撸了几天代码撸出来的结果，在这里权当记录吧，也算是学习数据结构与算法课程的一点小思考。

关于算法性能度量，是用的我自己想的一个方法（没怎么学习过高性能分析，就全部自创了）：}

^{定义基准速率比为测试算法与快速排序算法运行 1 到 12 的全排列的

排序总时间之比}

^{void check_speed(int n,bool show = false)
{cout << "运行中..." << endl;int a[n],b[n];clock_t reclaim = 0;for(int i = 1;i <= n;i++)a[i - 1] = i;clock_t myt=clock();do{for(int i = 0;i < n;i++)b[i] = a[i];}while(std::next_permutation(a,a+n));reclaim = clock() - myt;printf("初始化用时：%f s\t%ld\n",(long)reclaim / CLOCKS_PER_SEC,reclaim);myt=clock();do{for(int i = 0;i < n;i++)b[i] = a[i];qsort(b,n,sizeof(int),[](const void* a,const void* b)->int{return *(int*)a > *(int*)b;});}while(std::next_permutation(a,a+n));myt = clock() - myt - reclaim;printf("快速排序用时(n=%d)： %ld\n", n, myt);for(int i = 1;i <= n;i++)a[i - 1] = i;myt=clock();do{for(int i = 0;i < n;i++)b[i] = a[i];if(show)show_a(a,n);Merge_sort(b,n,[](int a,int b)->bool{return a < b;});}while(std::next_permutation(a,a+n));myt = clock() - myt - reclaim;printf("测试排序用时(n=%d)： %ld\n", n, myt);
}}

^{用ctime库时间处理的很粗糙，如果有人有更好的方法，欢迎留言交流。}

^{对满足方法1的子串，采用方法1交换；不满足方法1的采用方法2交换。 ↩︎}
^{最近看C++标准库，里面已经实现了这个方法：http://www.cplusplus.com/reference/algorithm/inplace_merge/ ↩︎}