阿里巴巴面试题|完美洗牌问题

原题概要

给定一个降序的正数数组，要求按【最小、最大、次小、次大…】的顺序重新排序。期望的时间复杂度为O（n），空间复杂度为O（1）,即不能申请额外数组。
例如：输入【7，6，5，4，3，2，1】
   输出【1，7，2，6，3，5，4】

思考历程

这道题是我在刷知乎的时候看到的，看到题目内容很简单，但在思考的时候却处处碰壁，然后我就打算好好研究这道题，也作为这一次不是leetcode上的算法作业了。
这道题如果给申请空间就非常简单，直接按顺序一个一个拿进来就可以了，但是一旦不能拿进来，题目就变得复杂多了。
我一开始是打算利用类似递归那种方法来做，也就是把【小，大】看成是一组，然后通过交换把【小，大】放在数组的前面，然后通过时间复杂度为O（n）然后把N-2的后面的数组重新排序为降序排序，但是因为移动后面的数字会花费大量时间，这样做出来的时间复杂度为O（n^2），不符合题目要求。

然后我就想，通过一种持续的交换，直到每一个数组都放在他最后的位置，这样时间复杂度应该会更小。然后通过稍微查找一下资料，发现这个问题是完美洗牌问题，只不过不同的是完美洗牌问题是要把[a1,a2,a3…,an,b1,b2,b3..,bn] 排序为 [b1,a1,b2,a2,…bn,an]，在直观上看这个问题非常相似，然而在本质上其实也是一样的。也就是我们可以把[b1,b2,b3..bn]通过时间复杂度为O（n）进行翻转。不过我没有这样做，而是利用完美洗牌的思想，加以针对化的改进改为适用这道题目。

算法分析

首先，针对于数组个数为奇数和偶数进行分类。
通过简单的分析其实很容易发现对于奇数个数的数组的最中间的数是放在结果的最后的，所以我们可以直接把奇数个数的情况变成偶数个数的情况。利用时间复杂度为O(n)即可把中间的数放到最后然后依次把后面的数往前推一格。

然后，我们可以发现在 中间往前的数
(一下的数字只代表下标不代表数值）
[0,1,2,3..(n-1)/2,(n-1)/2-1,…,n-1] 可以发现数组可以被看作是两部分组成，而分割线就在(n-1)/2 和 (n-1)/2-1 中间。前后两部分是按照不同的规则来放置的。
对于前半部分，可以观察出来
0->1  1->3  2->5  3->7
（前一个数字为初始下标，后一个数字为最终结果下标）
 可以看出来  结果下标 =（ 初始下标+1） *2 -1
 
 对于后半部分可以观察出来
 n-1 -> 0   n-2 -> 2   n-3 ->4  n-4 ->6
 （前一个数字为初始下标，后一个数字为最终结果下标）
可以看出来 结果下标 =（ n-1 - 初始下标） * 2
然后我们就可以按照这两个规则要一直交换到不能交换位置。
比如：  假设有一个大小为6的数组 下标[0,1,2,3,4,5]
那么我们从0开始进行交换：
0->1->3->4->2->5-0
按照这个顺序交换就能得到结果下标[5,0,4,1,3,2]
但是实际上那个数组可能不止有一个圈，所以还是需要一个外循环来检测哪些下标还没有进行交换。除此以外，很重要的一点是要观察那个下标到底进行了交换没有，在这里就要用到题目给出的一个条件，就是这些数字都是正数。所以，为了不另外申请标记空间，则利用取否来标记这些下标到底进行了交换没有，如果进行过交换，则该下标上的值为负值。稍微解释一下为什么用去否而不用取反，因为取反有可能会溢出，而取否肯定不会溢出，所以使用取否更为妥当。每一个数字只需要一步就可以到达结果位置所以时间复杂度也是O(N)
最后只用通过时间复杂度为O（n）把所有数字重新取否就可以得到结果。
所以最终的时间复杂度为 O(n)+ O(n) + O(n) =O(n

#include<iostream>
#include<vector>
using namespace std;

void sort(vector<int> & a)
{
    // 个数小于两个可以直接返回 
    if(a.size()<2) return ;
    int size = a.size();
    //  当个数为奇数的时候, 把中间那一单独的数直接放在最后
    //  然后个数减一，也就是把个数为奇数的情况重新变为偶数情况 
    if(size %  2 == 1) 
    {
        int mid = size /2 ;
        int temp = a[mid];
        for(int i = mid ;  i < size-1 ;i++)
        a[i] = a[i+1];
        a[size-1] = temp;
        size--; 
    }

    // 利用完美洗牌算法的思想；
    // 首先把数组均分（因为是偶数）
    int mid_index = (size-1) /2  ;
    int  from ,last_val, now_val;
    int i = 0 ;

    while(i<size)
    {  
    from = i ;
    last_val = a[from];
    for( ; a[from]> 0 ; )
    {
        int next,next_val;
        // 根据初始位置，它的下标计算方式不一样 
        if(from<=mid_index){
            next = (from+1) *2-1;
        }
        else {
            next = 2 *(size-1-from); 
        }

        next_val = a[next];
        a[next]= last_val;
        last_val = next_val;
        a[from] = ~a[from] ; //用作标记已经纳入圈里
        from = next; 
    } 
    i++;
    }
    for(int i = 0 ; i < size ; i++) // 重置 数值 
    a[i] = ~a[i];
}

int main()
{

    int n ;
    cin>>n;
    vector<int> a;
    for(int i = 0 ; i < n ; i++) 
    {
        int b; cin>>b;
        a.push_back(b);
    }

    sort(a);
    for(int i = 0 ; i < n ; i++)
    cout<<a[i]<<" ";
    return 0; 
}