算法：完美洗牌问题

OceanStar的学习笔记

已于 2022-07-20 09:22:24 修改

阅读量392

点赞数

分类专栏：算法与数据结构文章标签：数据结构

于 2022-07-19 16:54:10 首次发布

原文链接：https://blog.csdn.net/a2796749/article/details/48162989

版权

算法与数据结构专栏收录该内容

1121 篇文章 76 订阅

订阅专栏

题目

有个长度为2n的数组{a1,a2,a3,…,an,b1,b2,b3,…,bn}，希望排序后{a1,b1,a2,b2,….,an,bn}，请考虑有无时间复杂度o(n)，空间复杂度0(1)的解法。

在这里插入图片描述

题目解析

位置置换pefect_shuffle算法

为方便讨论，我们设定数组的下标从1开始，下标范围是[1…2n]。还是通过之前n=4的例子，来看下每个元素最终去了什么地方。

我们能看到，前n个元素中（n = 4）

第1个元素a1到了原第2个元素a2的位置，即1->2；
第2个元素a2到了原第4个元素a4的位置，即2->4；
第3个元素a3到了原第6个元素b2的位置，即3->6；
第4个元素a4到了原第8个元素b4的位置，即4->8；

那么推广到一般情况即是：前n个元素中，第i个元素去了第（2 * i）的位置。

上面是针对前n个元素，那么针对后n个元素（n = 4），可以看出：

第5个元素b1到了原第1个元素a1的位置，即5->1；
第6个元素b2到了原第3个元素a3的位置，即6->3；
第7个元素b3到了原第5个元素b1的位置，即7->5；
第8个元素b4到了原第7个元素b3的位置，即8->7；

推广到一般情况是，后n个元素，第i个元素去了第 $(2 * (i - n)) - 1 = 2 * i - (2 * n + 1) = (2 * i)$ 个位置。

再综合到任意情况，任意的第i个元素，我们最终换到了 $(2 * i)$ % $(2 * n + 1)$ 的位置。为何呢？因为：

当0< i <n时，原式= (2i) % (2 * n + 1) = 2i；
当i>n时，原式(2 * i) % (2 * n + 1)保持不变。

（2 * n的意思是数组长度，为8）

    // 数组的长度为len，调整前的位置是i，返回调整之后的位置
    // 下标不从0开始，从1开始
    int modifyIndex1(int i, int len){
        if(i <= len / 2){
            return  2 * i;
        }else{
            return 2 * (i - len / 2) - 1;
        }
    }

    // 数组的长度为len，调整前的位置是i，返回调整之后的位置
    // 下标不从0开始，从1开始
    int modifyIndex2(int i, int len){
        return (2 * i) %(len + 1);
    }

因此，如果题目允许我们再用一个数组的话，我们直接把每个元素放到该放得位置就好了。也就产生了最简单的方法pefect_shuffle1，参考代码如下：

// 时间O(n)，空间O(n) 数组下标从1开始   
void pefect_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(1)，肯定不能用暂存的方法，否则空间复杂度必然到达O(N) 。怎么办呢？

分而治之perfect_shuffle算法

当一个问题规模比较大时，则大而化小，分而治之，就是分治法。

假设n是偶数，我们试着把数组从中间拆分成两半(为了方便描述，只看数组下标就够了)：

原始数组的下标：1….2n，即（1 … n/2， n/2+1…n）（n+1 … n+n/2， n+n/2+1 … 2n）
前半段（1 … n/2， n/2+1…n）和后半段（n+1 … n+n/2， n+n/2+1 … 2n）的长度皆为n。

接下来，我们把前半段的后n/2个元素（n/2+1 … n）和后半段的前n/2个元素（n+1…n+n/2）交换，得到

新的前n个元素A：（1…n/2 n+1… n+n/2）
新的后n个元素B：（n/2+1 … n n+n/2+1 … 2n）

换言之，当n是偶数的时候，我们把原问题拆分成了A，B两个子问题，继而原n的求解转换成了n‘ = n/2 的求解。

可当n是奇数的时候呢？我们可以把前半段多出来的那个元素a先拿出来放到末尾，后面所有元素前移，于此，新数列的最后两个元素满足已满足要求，只需考虑前2*(n-1)个元素即可，继而转换成了n-1的问题。

举个例子。

当n是4时

在这里插入图片描述

当n是5时

在这里插入图片描述

实现

完美perfect_shuffle算法

因为之前无论是perfect_shuffle1，还是perfect_shuffle2，这两个算法的均未达到时间复杂度O（N）并且空间复杂度O（1）的要求，所以我们必须得再找一种新的方法，以期能完美的解决本节开头提出的完美洗牌问题。

换个思路，下标连环怼：

前置：在第一个置换洗牌算法中，我们已经知道，每个位置的元素都将变为第（2*i） % （2n+1）个元素
我们思考： $a 1$ 从位置1移到位置2时，那么，位置2上的元素 $a 2$ 变化到了哪里呢？继续这个过程，我们得到了一个“封闭”的环：

1 -> 2 -> 4 -> 8 -> 7 -> 5 -> 1

沿着这个环，可以把a1、a2、a4、b4、b3、b1这6个元素依次移动到最终位置；
此外，该变化的另外一个环是：

3 -> 6 -> 3

沿着这个环，可以把a3、b2这2个元素依次移动到最终位置。

在这里插入图片描述
如果我们知道有几个环，而且能算出每个环的起始位置，然后使用这个沿着圈走的算法就可以洗牌了

//数组下标从1开始，from是圈的头部，mod是要取模的数 mod 应该为 2 * n + 1，时间复杂度O(圈长）  
void cycle_leader(int *a,int from, int mod) {  
	int last = a[from],t,i;  
      
    for (i = from * 2 % mod;i != from; i = i * 2 % mod) {  
        t = a[i];  
        a[i] = last;  
        last = t;  
          
    }  
    a[from] = last;  
}

事实上，该问题的研究成果已经由Peiyush Jain在10年前公开发表在A Simple In-Place Algorithm for In-Shuffle, Microsoft, 2004中。原始论文直接使用了一个结论

对于 $2*n =（3^k-1）$ 这种长度的数组，恰好只有k个环，且每个环的起始位置分别是 $1,3,9，…3^(k-1)$ 。
对于上面的例子，长度为8，是 $3^2-1$ ，因此，只有2个环。环的起始位置分别是1和3。

至此，完美洗牌算法的“主体工程”已经完工，只存在一个“小”问题：如果数组长度不是（ $3^k-1$ ）呢？

若2n!=（ $3^k-1$ ），则总可以找到最大的整数m，使得m< n，并且2m =（ $3^k-1$ ）。
我们的做法是使用循环左移算法将[m+1……n]之间的元素移动到m+n之后，将[1……m] 和[n+1……n+m]合并成为一个长度为2*m的数组进行环操作，这个2m数组是可以被完整移动的

算法流程

输入数组 $A [1..2 * n]$

找到 $2 * m = 3^k - 1$ 使得 $3^k <= 2 * n < 3^{k +1}$
把a[m + 1…n + m]那部分循环移m位
对每个 $i = 0,1,2..k - 1，3^i$ 是个圈的头部，做cycle_leader算法，数组长度为m，所以对 $2 * m + 1$ 取模。
对数组的后面部分 $A [2 * m + 1..2 * n]$ 继续使用本算法, 这相当于n减小了m。

以上各个步骤对应的时间复杂度分析如下：

因为循环不断乘3的，所以时间复杂度O(logn)
循环移位O(n)
每个圈，每个元素只走了一次，一共2*m个元素，所以复杂度omega(m), 而m < n，所以也在O(n)内。
T(n - m)

因此总的时间复杂度为 T(n) = T(n - m) + O(n) ，m = omega(n) ，解得：T(n) = O(n)。

题目

来源

牛客网

题目

给定一个数组arr，请将数组调整为依次相邻的数字，总是先<=、再>=的关系，并交替下去。比如数组中有五个数字，调整成[a,b,c,d,e],使之满足a<=b>=c<=d>=e。

思路：

按照这个题对空间复杂度O(1)的要求，其实应该先用堆排序对数组进行排序，然后分数组长度为偶数和奇数两种情况分别进行处理：
- 如果数组长度为偶数，就先对数组进行完美洗牌，然后对洗牌后的数组构建一个长度为2的滚动窗口，每次交换窗口中的两个数就能达成题目的要求；
- 如果数组长度为奇数，则第一个元素不动，从第二个到最后一个元素进行完美洗牌就可以了。

实现

class ShuffleProblem{
    // 数组的长度为len，调整前的位置是i，返回调整之后的位置
    // 下标不从0开始，从1开始
    int modifyIndex1(int i, int len){
        if(i <= len / 2){
            return  2 * i;
        }else{
            return 2 * (i - len / 2) - 1;
        }
    }

    // 数组的长度为len，调整前的位置是i，返回调整之后的位置
    // 下标不从0开始，从1开始
    int modifyIndex2(int i, int len){
        return (2 * i) %(len + 1);
    }


    // 从start位置开始，往右len的长度这一段，做下标连续推
    // 出发位置依次为1,3,9...
    void cycles(std::vector<int> &arr, int start, int len, int k){
        // 找到每一个出发位置trigger，一共k个
        // 每一个trigger都进行下标连续推
        // 出发位置是从1开始算的，而数组下标是从0开始算的。
        for (int i = 0, trigger = 1; i < k; i++, trigger *= 3) {
            int preValue = arr[trigger + start - 1];
            int cur = modifyIndex2(trigger, len);
            while (cur != trigger) {
                int tmp = arr[cur + start - 1];
                arr[cur + start - 1] = preValue;
                preValue = tmp;
                cur = modifyIndex2(cur, len);
            }
            arr[cur + start - 1] = preValue;
        }
    }

    // [L..R]做逆序调整
    void reverse(std::vector<int> & arr, int L, int R) {
        while (L < R) {
            int tmp = arr[L];
            arr[L++] = arr[R];
            arr[R--] = tmp;
        }
    }

    // [L..M]为左部分，[M+1..R]为右部分，左右两部分互换
    void rotate(std::vector<int> &arr, int L, int M, int R) {
        reverse(arr, L, M);
        reverse(arr, M + 1, R);
        reverse(arr, L, R);
    }

    // 在arr[L..R]上做完美洗牌的调整（arr[L..R]范围上一定要是偶数个数字）
    void shuffle(std::vector<int> &arr, int L, int R){
        while (R - L + 1 > 0) { // 切成一块一块的解决，每一块的长度满足(3^k)-1
            int len = R - L + 1;
            int base = 3;
            int k = 1;
            // 计算小于等于len并且是离len最近的，满足(3^k)-1的数
            // 也就是找到最大的k，满足3^k <= len+1
            while (base <= (len + 1) / 3) { // base > (N+1)/3
                base *= 3;
                k++;
            }
            // 3^k -1
            // 当前要解决长度为base-1的块，一半就是再除2
            int half = (base - 1) / 2;
            // [L..R]的中点位置
            int mid = (L + R) / 2;
            // 要旋转的左部分为[L+half...mid], 右部分为arr[mid+1..mid+half]
            // 注意在这里，arr下标是从0开始的
            rotate(arr, L + half, mid, mid + half);
            // 旋转完成后，从L开始算起，长度为base-1的部分进行下标连续推
            cycles(arr, L, base - 1, k);
            // 解决了前base-1的部分，剩下的部分继续处理
            L = L + base - 1; // L ->     [] [+1...R]
        }
    }

    // 数组必须不为空，且长度为偶数
    void shuffle(std::vector<int> &arr){
        if(!arr.empty() && ((arr.size() & 1) == 0)){
            shuffle(arr, 0, arr.size() - 1);
        }
    }

private:
    bool  isValidWiggle(std::vector<int>& arr) {
        for (int i = 1; i < arr.size(); i++) {
            if ((i & 1) == 1 && arr[i] < arr[i - 1]) {
                return false;
            }
            if ((i & 1) == 0 && arr[i] > arr[i - 1]) {
                return false;
            }
        }
        return true;
    }
public:

    void wiggleSort(std::vector<int> arr) {
        if ( arr.empty() == 0) {
            return;
        }
        // 假设这个排序是额外空间复杂度O(1)的，当然系统提供的排序并不是，你可以自己实现一个堆排序
        std::sort(arr.begin(), arr.end());
        if ((arr.size() & 1) == 1) {
            shuffle(arr, 1, arr.size() - 1);
        } else {
            shuffle(arr, 0, arr.size() - 1);
            for (int i = 0; i < arr.size(); i += 2) {
                int tmp = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = tmp;
            }
        }
    }
};