《编程珠玑(第2版)》笔记——将一个n元一维向量向左旋转i个位置（第2章）

 

转载自:http://blog.csdn.net/gavinming/article/details/7225275

第2章 啊哈！算法

《编程珠玑(第2版)》的第2章，一开始就给出三个问题，其中问题B很有意思：将一个n元一维向量向左旋转i个位置。例如，当n=8且i=3时，向量abcdefgh旋转为defghabc。简单的代码使用一个n元的中间向量在n步就能够完成该工作，你能否仅使用数十个额外字节的存储空间，正比于n的时间内完成向量旋转。

其实就像问题中提到的，如果不考虑空间，这是个很简单的问题。但考虑到空间的时候，能否灵巧地解决该问题？

书中给出了2个比较精巧的方法：

1.求模置换的方法：

其实我们知道有个节约空间的方案：每次向左旋转一个位置（其时间正比于n），总共需要旋转i次。这个方案会消耗过多的运行时间。而求模置换的方法则是尽量让每个数一次移动到位。总体的思想是:以i为除数对n求模，将向量遍历完并一次移动到位。看下面两个例：

示例数组： {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}

(1)n=12且i=5：

(2)n=12且i=3：

上述两图展示了两种不同的情况，示例(1)的n=12和i=5最大公约数是1，因此不断求模能够无重复完整遍历数组；而示例(2)中n=12且i=3，有最大公约数3，因此移动3个位置就会出现重复，因此需要移动到下一位再次求模共3次：

[cpp] view plaincopyprint?

1. //求公约数 
2. unsigned int Gcd(unsigned int a, unsignedint b) 
3. { 
4.     unsigned int temp; 
5.     while (b != 0) 
6.     { 
7.         temp = a % b; 
8.         a = b; 
9.         b = temp; 
10.     } 
11.  
12.     return a; 
13. } 
14.  
15. void modShift(int array[],int n,int rotdist) 
16. { 
17.     unsigned int gcd = Gcd(n, rotdist); 
18.  
19.     for (int i = 0; i < gcd; i ++) 
20.     { 
21.         int temp = array[i]; 
22.         int j = i; 
23.         int k; 
24.         while(1) 
25.         { 
26.             int k = j +  rotdist; 
27.             if (k >= n) 
28.             { 
29.                 k -= n; 
30.             } 
31.              
32.             if (k == i) 
33.             { 
34.                 break; 
35.             } 
36.  
37.             array[j] = array[k]; 
38.             j = k; 
39.         } 
40.         array[j] = temp; 
41.     } 
42.  
43. } 

//求公约数unsigned int Gcd(unsigned int a, unsigned int b){unsigned int temp;while (b != 0){temp = a % b;a = b;b = temp;}return a;}void modShift(int array[], int n, int rotdist){unsigned int gcd = Gcd(n, rotdist);for (int i = 0; i < gcd; i ++){int temp = array[i];int j = i;int k;while(1){int k = j +  rotdist;if (k >= n){k -= n;}if (k == i){break;}array[j] = array[k];j = k;}array[j] = temp;}}

2.分段递归交换的方法：

旋转向量x其实就是交换向量ab的两段，得到ba（a代表x中的前i个元素）。假设a比b短，将b分为b1和b2两段，使b2有跟a相同的长度，然后交换a和b2，也就是ab1b2交换得到b2b1a，a的位置已经是最终的位置，现在的问题集中到交换b2b1这两段，又回到了原来的问题。不断递归下去，到b1和b2的长度长度相等交换即可。代码如下

[cpp] view plaincopyprint?

1. //swapShift 
2. //swap x[a .. a+offset-1] and x[b .. b+offset-1] 
3. void swap(int array[],int a,int b,int offset) 
4. { 
5.     int temp; 
6.     for (int i = 0; i < offset; i++) 
7.     { 
8.         temp = array[a + i]; 
9.         array[a + i] = array[b + i]; 
10.         array[b + i] = temp; 
11.     } 
12. } 
13.  
14.  
15. void swapShift(int *array,int n,int rotdist) 
16. { 
17.     int p = rotdist; 
18.     int i = p; 
19.     int j = n - p; 
20.  
21.     while (i != j) 
22.     { 
23.         if (i > j) 
24.         { 
25.             swap(array, p - i, p, j); 
26.             i -=j; 
27.         } 
28.         else 
29.         { 
30.             swap(array, p - i, p + j - i, i); 
31.             j -= i; 
32.         } 
33.     } 
34.     swap(array, p - i, p, i); 
35. } 

//swapShift//swap x[a .. a+offset-1] and x[b .. b+offset-1]void swap(int array[], int a, int b, int offset){int temp;for (int i = 0; i < offset; i++){temp = array[a + i];array[a + i] = array[b + i];array[b + i] = temp;}}void swapShift(int *array, int n, int rotdist){int p = rotdist;int i = p;int j = n - p;while (i != j){if (i > j){swap(array, p - i, p, j);i -=j;}else{swap(array, p - i, p + j - i, i);j -= i;}}swap(array, p - i, p, i);}

3.求逆法（翻手算法）

利用向量原理：把x向量分成ab两部分，a是前i个元素，b是后n-i个元素，首先对a求逆，得到a-1b，然后对b求逆得到a-1b-1，然后对整体求逆得到（a-1b-1）-1=ba。

非常容易理解，代码如下：

[cpp] view plaincopyprint?

1. //Reverse 
2. void reverse(int array[],int low,int high) 
3. { 
4.     int temp = 0; 
5.     for(int i = low; i <= (high + low) / 2; i++) 
6.     { 
7.         temp = array[i]; 
8.         array[i] = array[high - (i - low)]; 
9.         array[high - (i - low)] = temp; 
10.     } 
11. } 
12.  
13. void reverseShift(int *array,int n,int rotdist) 
14. { 
15.     reverse(array, 0, rotdist - 1); 
16.     reverse(array, rotdist, n - 1); 
17.     reverse(array, 0, n - 1); 
18. } 

//Reversevoid reverse(int array[], int low, int high){int temp = 0;for(int i = low; i <= (high + low) / 2; i++){temp = array[i];array[i] = array[high - (i - low)];array[high - (i - low)] = temp;}}void reverseShift(int *array, int n, int rotdist){reverse(array, 0, rotdist - 1);reverse(array, rotdist, n - 1);reverse(array, 0, n - 1);}

翻手算法代码非常简短，非常容易理解，而且针对字符串的求逆也不用自己写函数，在时间和空间上都很高效。

总结：

一个简单的问题，在不同的角度，可以找到不同的方法，主要要做到发散思维，找到高效又容易理解的方法。