完美洗牌算法（2013年UC校招笔试、2016阿里实习生笔试）
题目详情：有个长度为2n的数组{a1,a2,a3,...,an,b1,b2,b3,...,bn}，希望排序后{a1,b1,a2,b2,....,an,bn}，要求时间复杂度O(n)，空间复杂度0(1)的解法。
思路一：位置置换pefect_shuffle1算法
数组下标：1 2 3 4 5 6 7 8
最终序列：b1 a1 b2 a2 b3 a3 b4 a4
从上面的例子我们能看到，前n个元素中，
时间复杂度：O(n) 空间：O(n)
我们设定数组的下标从1开始，下标范围是[1..2n]。 还是通过之前n=4的例子，来看下每个元素最终去了什么地方。
起始序列：a1 a2 a3 a4 b1 b2 b3 b4
1、第1个元素a1到了原第2个元素a2的位置，即1->2；
2、第2个元素a2到了原第4个元素a4的位置，即2->4；
3、第3个元素a3到了原第6个元素b2的位置，即3->6；
4、第4个元素a4到了原第8个元素b4的位置，即4->8；
那么推广到一般情况即是：前n个元素中，第i个元素去了 第（2 * i）的位置。
上面是针对前n个元素，那么针对后n个元素，可以看出：
5、第5个元素b1到了原第1个元素a1的位置，即5->1；
6、第6个元素b2到了原第3个元素a3的位置，即6->3；
7、第7个元素b3到了原第5个元素b1的位置，即7->5；
8、第8个元素b4到了原第7个元素b3的位置，即8->7；
推广到一般情况是，后n个元素，第i个元素去了第 (2 * (i - n) ) - 1 = 2 * i - (2 * n + 1) = (2 * i) % (2 * n + 1) 个位置。
再综合到任意情况，任意的第i个元素，我们最终换到了 (2 * i) % (2 * n + 1)的位置。
为何呢？因为：
当0< i
当i>n时，原式(2 * i) % (2 * n + 1)保持不变。
因此，如果题目允许我们再用一个数组的话，我们直接把每个元素放到该放得位置就好了。也就产生了最简单的方法pefect_shuffle1。
但很明显，它的时间复杂度虽然是O(n)，但其空间复杂度却是O(n)《需要开辟一个新的数组》，仍不符合本题所期待的时间O(n)，空间O(1)。
注意：根据上面变换的节奏，我们可以看出有两个圈：
一个是1 -> 2 -> 4 -> 8 -> 7 -> 5 -> 1；
一个是3 -> 6 -> 3。
思路二：完美洗牌算法2---分治的力量
时间复杂度：O(nlogn) 空间复杂度：O(1)
a1, a2,a3,a4,b1,b2,b3,b4
我们先要把前半段的后2个元素(a3,a4)与后半段的前2个元素(b1,b2)交换，得到a1,a2,b1,b2,a3,a4,b3,b4。
于是，我们分别求解子问题A (a1,a2,b1,b2)和子问题B (a3,a4,b3,b4)就可以了。
最终得到：a1,b1,a2,b2,a3,b3,a4,b4
如果n = 5，是偶数怎么办？我们原始的数组是a1,a2,a3,a4,a5,b1,b2,b3,b4,b5，我们先把a5拎出来，后面所有元素前移，再把a5放到最后，变为a1,a2,a3,a4,b1,b2,b3,b4,b5,a5。可见这时最后两个元素b5,a5已经是我们要的结果了，所以我们只要考虑n=4就可以了。
那么复杂度怎么算？ 每次，我们交换中间的n个元素（左边靠后的n/2个元素和右边靠前的n/2个元素），需要O(n)的时间，n是奇数的话，我们还需要O(n)的时间先把后两个元素调整好，但这不影响总体时间复杂度。所以，无论如何都是O(n)的时间复杂度。
于是我们有 T(n) = T(n / 2) + O(n) 这个就是跟归并排序一样的复杂度式子，最终复杂度解出来T(n) = O(nlogn)。空间的话，我们就在数组内部折腾的，所以是O(1)。（当然没有考虑递归的栈的空间）
思路三：完美洗牌算法
首先，对于每一个元素，它最终都会到达一个位置，我们如果记录每个元素应到的位置会形成圈。 为什么会形成圈？ 比如原来位置为a的元素最终到达b，而b又要达到c……，因为每个新位置和原位置都有一个元素，所以一条链 a->b->c->d……这样下去的话，必然有一个元素会指向a，（因为中间那些位置b,c,d……都已经被其它元素指向了）。 这就是圈的成因。
比如 6个元素 原始是(1,2,3,4,5,6), 最终是(4,1,5,2,6,3),我们用a->b表示原来下标为a的元素，新下标为b了。
1->2
2->4
3->6
4->1
5->3
6->5
在论文“A Simple In-Place Algorithm for In-Shuffle. Peiyush Jain, Microsoft Corporation. ”中，给出了一个很牛的结论：
:对于2 * n = (3^k - 1)，这种长度的数组，恰好只有k个圈，并且每个圈的头部是1,3,9,...3^(k - 1)。此处的n为特殊的值（偶数）；对于任意的n，参考思路二，把它拆成两部分，前一部分是满足上述结论的，后一部分再单独算。
为了把数组分成适当的两部分，我们同样需要交换一些元素，但这时交换的元素个数不相等，不能简单地循环交换，我们需要更强大的工具——循环移。假设满足结论(*)的需要的长度是2 * m = (3^k - 1)， 我们需要把n分解成m和n - m两部分，按下标来说，是这样：
原先的数组(1..m) (m + 1.. n) (n + 1..n + m)(n + m + 1..2 * n)，我们要达到的数组 (1..m)(n + 1.. n + m)(m + 1..n)(n + m + 1..2 * n)。可见，中间那两段长度为(n - m)和m的段需要交换位置，这个相当于把(m + 1..n + m)的段循环右移m次，而循环右移是有O(长度)的算法的, 主要思想是把前(n - m)个元素和后m个元素都翻转一下，再把整个段翻转一下。
再用a和b举例一下，设n = 7这样m = 4, k = 2
原先的数组是a1,a2,a3,a4,(a5,a6,a7),(b1,b2,b3,b4),b5,b6,b7。
结论(*)是说m = 4的部分可以直接搞定，也就是说我们把中间加括号的那两段(a5,a6,a7) (b1,b2,b3,b4)交换位置，也就是把(a5,a6,a7,b1,b2,b3,b4)整体循环右移4位就可以得到：(a1,a2,a3,a4,b1,b2,b3,b4)(a5,a6,a7,b5,b6,b7)
于是前m = 4个由cycle_leading算法直接搞定，n的长度减小了4。
所以这也是一种分治算法。
算法流程：
输入数组 a[1..2 * n]
step 1 找到 2 * m = 3^k - 1 使得 3^k <= 2 * n < 3^(k +1)
step 2 把a[m + 1..n + m]那部分循环移m位
step 3 对每个i = 0,1,2..k - 1，3^i是个圈的头部，做cycle_leader算法，数组长度为m，所以对2 * m + 1取模。
step 4 对数组的后面部分a[2 * m + 1.. 2 * n]继续使用本算法，这相当于n减小了m。(只对n’等于奇数的那部分使用本算法)
时间复杂度分析：
1 因为循环不断乘3的，所以时间复杂度O(logn)
2 循环移位O(n)
3 每个圈，每个元素只走了一次，一共2*m个元素，所以复杂度omega(m),
而m < n，所以 也在O(n)内。
4 T(n - m)
因此 复杂度为 T(n) = T(n - m) + O(n) m = omega(n)
所以，总复杂度T(n) = O(n)
总结：完美洗牌算法中，先使用神级结论将原始数组进行处理，分成两部分，对于每部分来说，如果m（每部分的长度为2m）是奇数的话就再使用一次完美洗牌算法，m为偶数的那部分直接使用cycle_leading算法搞定就可以了，当然了，如果两部分都是偶数的话，多次使用cycle_leading算法最省时间啦。
//完美洗牌算法（2013年UC校招笔试、2016阿里实习生笔试）
//思路一
//时间复杂度O(n)，空间O(n)
void perfect_shuffle1(int *a,int n)
{
int n2=n*2,i,b[N];
for(i=1;i<=n2;++i)
{
b[(i*2)%(n2+1)]=a[i];
}
for(i=1;i<=n2;++i)
{
a[i]=b[i];
}
}
//思路二
//时间O(nlogn) 空间O(1)
void perfect_shuffle2(int *a,int n)//数组a及长度n
{
int t,i;
if(n==1)
{
t=a[1];
a[1]=a[2];
a[2]=t;
return;
}
int n2=n*2,n3=n/2;
if(n%2==1)
{
t=a[n];
for(i=n+1;i1)
{
//step1
n2=n*2;//数组总长度
for(k=0,m=1;n2/m>=3;++k,m*=3);
m/=2;
// 2m = 3^k - 1 , 3^k <= 2n < 3^(k + 1)
// step 2
right_rotate(a+m,m,n);//将长度为n的数组右移m位
//step3
for(i=0,t=1;i