数组移动算法

ASH前段时间贴出了一个问题：

对于有K个元素的数组 int a[K]={....};写一个高效算法将数组内容循环左移m位

比如：  int a[6] ={1,2,3,4,5,6} ,循环左移3位得到结果{456123},
要求：
1不允许另外申请数组空间，但可以申请少许变量
2不允许采用每次左移

这是一个有趣的问题，当时ASH给出了一个很简单的解法：
1、将整个数组倒排；
2、将前k-m个元素和剩下的m个元素分别倒排。

这个算法需要对每个数组元素做两次写操作，所以我当时在考虑，有没有一种方法，只对数组元素进行一次写操作就完成移动？

最直观的想法，就是从第一个元素开始，把它一步移动到最终的目的位置，而该位置原有的元素的值取出，移动到它的新位置。递归进行这个步骤。
首先，我们在数学上很容易理解，这是一个一一对应的映射，绝不会在一个位置上出现两次移动。所以不会出现移动的递归过程中途指向了已经移动过的元素。
那么，这个递归过程唯一的终止条件就是，当前移动的元素，目的位置是移动过程的起始位置。

有兴趣的朋友不妨在纸上推演一下这个过程，并不复杂。多试验几种组合，细心的朋友也许会发现，这个递归过程有时候可以遍历整个数组，有时候则会跳过若干元素。这其中有没有什么规律？
如果按照元素的索引下标标示元素，0到k-1中的任意元素i，会移动到什么位置？
如果i小于m，它会移动到k-m+i，否则，它的新位置是i-m。在小小飞和ASH的讲解下，我理解了这个过程其实可以统一在一个算式下：
对于任意的i，它的新位置i' = ((k - m) + i )%k
那么，我们可以定义这个循环链：取整数i0，使得0=<i0<m，定义i1=((k-m)+i0)%k，i2=((k-m) + i1)%k……ix =
((k-m) + ix-1)%k。当ix=i0时循环终止。此时有i0 = ix = ((k-m) + ix-1)%k =
……=(x(k-m)+i0)%k
因为我们知道0=<i0<m，所以有0 = x(k-m)%k，也就是说，x(k-m) = yk，因为我们是遇到第一个x(k-m) =
yk就终止，显然等号左右的值就是k-m和k的最小公倍数。根据数论知识，我们知道，k，m，k-m这三个数有最大公约数q，使得k=aq，m=bq，k-m=cq，a，b，c三个数两两互质。进而推出x
= a，y =
c。也就是说，这个递归过程会经历a步。如果k和m互质，a=k，也就是说，递归过程会遍历整个区间。那么，它可以完成对整个区间的移动操作。而如果k和 m的最大公约数q>1呢？在这里有一个现象，任意两个i，它们的差要么是0，要么是k和m的最大公因是q的整倍数。有兴趣的朋友可以尝试证明一下。因为我们知道整个过程一共a步，k=aq，那么，i到ix的序列会形成一个步长为q的等差序列。所以，我们要移动整个0到k-1区间，应该对0到q-1的元素应用这个递归算法。

据此，我编写了算法带代码，并进行了泛化，使之可以适用于不同的类型，包括用不同整型变量表示k,m等参数的应用：
求最大公因数，辗转相除，可以应用于任何求最大公因式/数的场合，只要参数类型支持求余和赋值：

template<typename intT>
intT HCF(const intT & x, const intT & y)
{
    intT a = x;
    intT b = y;
    intT r = a%b;

    while(r != 0)
    {
        a = b;
        b = r;
        r = a%b;
    }
    return b;

 

};

区间移动，支持任何类型的数组：

template<typename T,typename U>
void Carry(T point[], const U & len, const U & m)
{
    U start = 0;
    U p = 0;
    T pv;
    U hloc = HCF(len, m);
    U step = len - m;
    for (U i = 0; i<hloc; i++)
    {
        p = i;
        start = p;
        pv = point[p] ;
        do
        {
            p = (step+p)%len;
            std::swap(point[p] , pv);
        }while(p != start);
    }

 

};

用迭代器实现的区间移动，可以应用于STL容器等场合：

template<typename iterT,typename U>
void Carry(iterT &iter, const U & len, const U & m)
{
    iterT nb = iter + (len-m);
    iterT p;
    iterT start = point;
    iterT pm = point + m;
    iterator_traits<iterT>::value_type pv;
    U hloc = HCF(len, m);
    for (U i = 0; i<hloc; i++)
    {
        p = point + i;
        start = p;
        pv = *p ;
        do
        {
            if (p < pm)
                p = nb + (p - point);
            else
                p -= m;

            std::swap(*p , pv);
        }while(p != start);
    }

 

};

算法评估：表面上看，ASH的两步倒排需要对数组进行两次写操作，我的算法只需要一次。但是我要承认，因为需要一个中间变量保存当前要移动的元素，其实我要比ASH的算法多一倍的堆变量赋值。另外每一步迭代我要计算目的位置，所以我不敢肯定我的算法就更快一些，对于我来说，它带给我的是思考的乐趣：）。

代码中使用了std::swap函数来交换变量值，这个函数在<algorithm>中。另外为了析取迭代器的值，我使用了<iterator>中的iterator_traits操作。有兴趣的朋友不妨编写一个适用于普通指针的偏特化版本。