算法 （向量旋转）

算法 （向量旋转）

分类： 编程珠玑2011-12-12
11:01 623人阅读 评论(0) 收藏 举报

算法distance存储inputini测试

将一个n元一维向量向左旋转i个位置。例如，当n=8且i=3时，向量abcdefgh旋转为defghabc。简单的代码使用一个n元的中间向量在n步内完成该工作。你能否仅使用数十个额外字节的存储空间，在正比于n的时间内完成向量的旋转？

“旋转操作对应于交换相邻的不同大小的内存块：每当拖动文件中的一块文字到其他地方时，就要求程序交换两块内存中的内容。在许多应用场合下，运行时间和存储空间的约束会很严格。”

“通过如下方式解决该问题：首先将x的前i个元素复制到一个临时数组中，然后将余下的n-i个元素向左移动i个位置，最后将最初的i个元素从临时数组中复制到x中余下的位置。但是这种方法使用的i个额外的位置产生了过大的存储空间消耗。另一种方法是定义一个函数将x向左旋转一个位置(其时间正比于n)然后调用该函数i次。但该方法又产生了过多的运行时间消耗。”

杂技算法：

“移动x[0]到临时变量t，然后移动x[i]至x[0]，x[2i]至x[i]，依此类推(将x中的所有下标对n取模)，直至返回到取x[0]中的元素，此时改为从t取值然后终止过程。如果该过程没有移动全部元素，就从x[1]开始再次进行移动，直到所有的元素都已经移动为止。”

最大公约数为1的能够填满数据，否则不能填满 x[0]<->x[i]<->x[2i]， x[1]<->x[i+1]<->x[2i+1]，需最大公约数次移动。

两个相差1的数的最大公约数不可能是2。若两个数a,b的最大公约数为1，则将其中的一个数(假设为a)增加任意数k并对b求余，则结果为0...b-1。基于这个道理若数组的长度和旋转的长度的最大公约数为1，则从数组的某位开始以任意长度k(此处为旋转长度)为步长遍历数组，则每个元素都可以遍历到。通过移位操作若第k+1个元素到达指定的位置，则通过一次遍历所有元素都将到达指定位置。若最大公约数不为1则需要遍历最大公约数次。

[cpp] view
plaincopy

int gcd(int a, int b)

{

while(a!=b)

{

if(a>b)

a-=b;

else

b-=a;

}

return a;

}

void jugglerot(int n, int rotdist)

{

int i, j, m, temp, r, k=0;

m=gcd(n, rotdist); //求最大公约数

while(m)

{

i=rotdist+k;

j=k;

temp=x[j];

r=j;

//while(i!=j) i和j都是变化的，故不能用j做标签，需要用另外一个值r

while(i!=r)

{

x[j]=x[i];

j=i;

i=(i+rotdist)%n;

//i=i%n;

//j=j+rotdist;

//j=j%n;

}

//x[i]=temp;

x[j]=temp;

k++;

m--;

}

}

块交换算法：



“旋转向量x其实就是交换向量ab的两段，得到向量ba。这里a代表x中的前i个元素。假设a比b短，将b分为bl和br，使得br具有与a相同的长度。交换a和br，也就是将ablbr 。序列a此时已处于其最终的位置，因此现在就集中到交换b的两部分。由于新问题与原来的问题具有相同的形式，我们可以递归地解决之。”

数组作为全局变量直接在程序中引用，不加入形参。

用i和j代表两个长度，其中i表示还需要旋转的元素长度(i<=n)，j表示剩余的还没有到指定位置的元素长度。 其中初始值为 i=rotdist, j=n-rotdist --> 由于i,j长度不等中间利用swap交换调整两块元素内容(利用长度短的部分截断长度长的部分以交换) --> 终止条件为 i=j(这样看gcdrot为不等长的swap) --> 最后再完成一次交换。

因为数组为从左到右的顺序0,1,2...所以调整过程分为i>j和i<j两种情况。利用p记录旋转长度(不变)，需要旋转的元素(长度i表示)均在p长度内，即需旋转元素的最远端在数组p-1的位置(想象i=p=T,j=T-1的情况|****|***|)。

关键是找准调用数组的边界以带入swap函数，并且程序是循环执行，所以边界应该由i,j,p三个变量可以表示出来，那么该怎样表示呢？这时想起两个办法：一、由一般情况总结某种规律(量变)。二、考虑特殊的情况(产生了质变)。我是这么想的，以i<j为例，从左到右进行旋转，则其实左端i的长度及起始位置是不变的，而右端j的长度不断减小并且起始位置在不断地改变(越来越向前)，那么接下来呢？这个过程会一直持续下去吗？在j>i时可能是j=i+1,j=i+2等，那么在j不断减小的过程中可能在某处出现：1.j=i，此时程序的循环结束，做最后一次块交换即可，此时边界为swap(a,b,len)中a=0(p-i,p和i均没有变化),b=j(p-i+j,其中p-i为0可以定位a的位置，b与a相距p个单位),len=i=j=p。2.j<i，出现此种情况时程序开始需要从右向左进行旋转，a=0(p-i),b=p,len=j，旋转过后的i,j大小关系不确定，其中的边界表示为a=p-i(i此时已变化),b=p,len=j。从这个过程可以看出边界变化的规律，其中从左向右旋转时a是不变的，b不断减小，len不变，i不变，j减小。即a=p-i(a在另一种情况下是变化的，而且这两种情况相互渗透，但此时的i是不变的),b=p-i+j(更好的写法是p+j-i) ,len=i。从右向左旋转时a不断增大，b不变，len不变，i减小，j不变。即a=p-i，b=p，len=j。

更好的抽象方法还是书中给出的一个范围式：

x[0 ..p-i ] is in final position

x[p-i..p-1 ] = a (to be swapped with b)

x[p ..p+j-1] = b (to be swapped with a)

x[p+j..n-1 ] in final position

[cpp] view
plaincopy

// swap two blocks in the array x
, the blocks are [a...a+len-1] and [b...b+len-1]

void swap(int a, int b, int len)

{

int temp;

while(len)

{

temp=x[a];

x[a]=x;

x[b]=temp;

len--;

a++;

b++;

}

}

// gcdrot 与 gcd 算法同构

void gcdrot(int n, int rotdist)

{

// n is the array length, rotdist is the switch length

int i, j, p;

i=p=rotdist;

j=n-i;

while(i!=j)

{

if(i>j) // 空间形象为开始从右向左旋转

{

swap(p-i,p,j); // i不断减小，a是不断增长的

i-=j;

}

if(i<j) // 空间形象为开始从左向右旋转

{

swap(p-i,p+j-i,i);

j-=i;

}

}

swap(p-i,p,i);

}

[b]求逆算法：

"我们将问题看做是把数组ab转换成ba，同时假定我们拥有一个函数可以将数组中特定部分的元素求逆。从ab开始，首先对a求逆，得到arb，然后对b求逆，得到arbr。最后整体求逆，得到(arbr)r。此时恰好是ba。"

[cpp] view
plaincopy

// reversal rot

// 思想很简洁，代码也是一样若想求出ab的逆序ba,则先对a求逆，再对b求逆，最后对整体求逆

// reverse the array denoted by

// 还是 reverse(int i, int j)比较好 i,j代表了数组的范围

void reverse(int i, int n)

{

int temp, j;

j=i+n-1;

while(i<j)

{

temp=x[i];

x[i]=x[j];

x[j]=temp;

i++;

j--;

}

}

void reversalrot(int n, int rotdist)

{

revese(0,rotdist);

revese(rotdist,n-rotdist);

revese(0,n);

}

上述三个算法的主函数做测试用：

[cpp] view
plaincopy

#include <stdio.h>

#define N 1000

int x
;

int rotdist, n;

int main()

{

int i, n, rotdistance;

//init(); 初始化函数在下面表示出来

printf("Please input the number of the array:");

scanf("%d",&n);

// print the inital value of the array

for(i=0;i<n;i++)

{

x[i]=i;

printf("%d ",x[i]);

}

printf("\nPlease input the distance you want to rotate:");

scanf("%d",&rotdistance);

//gcdrot(n, rotdistance);

//jugglerot(n, rotdistance);

reversalrot(n, rotdistance);

for(i=0;i<n;i++)

printf("%d ",x[i]);

return 0;

}

书中给出的求逆算法源代码：

[cpp] view
plaincopy

/* Alg 1: Rotate by reversal */

void reverse(int i, int j)

{ int t;

while (i < j) {

t = x[i]; x[i] = x[j]; x[j] = t;

i++;

j--;

}

}

void revrot(int rotdist, int n)

{ reverse(0, rotdist-1);

reverse(rotdist, n-1);

reverse(0, n-1);

}