算法 （向量旋转）

分类： 编程珠玑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

1. int gcd(int a, int b)  
2. {  
3.     while(a!=b)  
4.     {  
5.                if(a>b)  
6.                a-=b;  
7.                else   
8.                b-=a;  
9.     }  
10.     return a;  
11. }  
12.   
13. void jugglerot(int n, int rotdist)  
14. {  
15.      int i, j, m, temp, r, k=0;  
16.      m=gcd(n, rotdist);  //求最大公约数  
17.      while(m)  
18.      {  
19.                      i=rotdist+k;  
20.                      j=k;  
21.                      temp=x[j];  
22.                      r=j;  
23.                      //while(i!=j)  i和j都是变化的，故不能用j做标签，需要用另外一个值r  
24.                      while(i!=r)  
25.                      {  
26.                             x[j]=x[i];  
27.                             j=i;  
28.                             i=(i+rotdist)%n;  
29.                             //i=i%n;  
30.                             //j=j+rotdist;  
31.                             //j=j%n;  
32.                      }  
33.                      //x[i]=temp;  
34.                      x[j]=temp;  
35.                      k++;  
36.                      m--;  
37.      }  
38. }   

块交换算法：

“旋转向量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

1. // swap two blocks in the array x[N], the blocks are [a...a+len-1] and [b...b+len-1]   
2. void swap(int a, int b, int len)  
3. {  
4.      int temp;  
5.      while(len)  
6.      {  
7.                temp=x[a];  
8.                x[a]=x[b];  
9.                x[b]=temp;  
10.                len--;  
11.                a++;  
12.                b++;  
13.      }  
14. }  
15.   
16. //  gcdrot 与 gcd 算法同构    
17. void gcdrot(int n, int rotdist)  
18. {  
19.      // n is the array length, rotdist is the switch length  
20.      int i, j, p;  
21.      i=p=rotdist;  
22.      j=n-i;  
23.      while(i!=j)  
24.      {  
25.                 if(i>j) // 空间形象为开始从右向左旋转   
26.                 {  
27.                        swap(p-i,p,j); // i不断减小，a是不断增长的   
28.                        i-=j;  
29.                 }  
30.                 if(i<j) // 空间形象为开始从左向右旋转   
31.                 {  
32.                        swap(p-i,p+j-i,i);  
33.                        j-=i;  
34.                 }  
35.      }  
36.      swap(p-i,p,i);   
37. }  

求逆算法：

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

[cpp] view plaincopy

1. // reversal rot  
2. // 思想很简洁，代码也是一样若想求出ab的逆序ba,则先对a求逆，再对b求逆，最后对整体求逆  
3. // reverse the array denoted by   
4. // 还是 reverse(int i, int j)比较好 i,j代表了数组的范围   
5. void reverse(int i, int n)  
6. {  
7.      int temp, j;  
8.      j=i+n-1;  
9.      while(i<j)  
10.      {  
11.                temp=x[i];  
12.                x[i]=x[j];  
13.                x[j]=temp;  
14.                i++;  
15.                j--;  
16.      }  
17. }  
18.   
19. void reversalrot(int n, int rotdist)  
20. {  
21.      revese(0,rotdist);  
22.      revese(rotdist,n-rotdist);  
23.      revese(0,n);  
24. }   

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

[cpp] view plaincopy

1. #include <stdio.h>  
2.   
3. #define N 1000  
4.   
5. int x[N];  
6. int rotdist, n;  
7.   
8. int main()  
9. {  
10.     int i, n, rotdistance;   
11.     //init(); 初始化函数在下面表示出来  
12.     printf("Please input the number of the array:");  
13.     scanf("%d",&n);  
14.     // print the inital value of the array   
15.     for(i=0;i<n;i++)  
16.     {  
17.                     x[i]=i;  
18.                     printf("%d ",x[i]);  
19.     }  
20.     printf("\nPlease input the distance you want to rotate:");  
21.     scanf("%d",&rotdistance);  
22.     //gcdrot(n, rotdistance);  
23.     //jugglerot(n, rotdistance);  
24.     reversalrot(n, rotdistance);  
25.     for(i=0;i<n;i++)  
26.         printf("%d ",x[i]);  
27.       
28.     return 0;  
29. }  

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

[cpp] view plaincopy

1. /* Alg 1: Rotate by reversal */  
2.   
3. void reverse(int i, int j)  
4. {   int t;  
5.     while (i < j) {  
6.         t = x[i]; x[i] = x[j]; x[j] = t;  
7.         i++;  
8.         j--;  
9.     }  
10. }  
11.   
12. void revrot(int rotdist, int n)  
13. {   reverse(0, rotdist-1);  
14.     reverse(rotdist, n-1);  
15.     reverse(0, n-1);  
16. }