编程珠玑之第二章questionB: n元一维向量旋转问题

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

问题解析：
1、以正比于n的时间(相当于n步内)完成该操作，那么就是每个元素的移动都差不多一步到位，如将第4位的d一步移动到第1位处，其他元素也也一样。
2、额外空间只有几十个字节，这里说明并不能将前i个保存到临时空间，这样当i很大时，会消耗过多的内存空间。
3、题目条件对运行时间和内存空间都有严格的限制，

解决方案：

作者给出的方案1：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54

#include <cstdio> #include <cstdlib>       // srand, rand #include <cassert>       // assert // 递归求最大公约数 int gcd( int a,   int b) {     assert(a >  0 && b >=  0);      if (b !=  0){  return gcd(b, a%b); }      return a; } /************************************************************************/ // 函数名称：my_reverse // 函数目的：对输入的数组循环移位进行反转 // 函数参数：arr：要反转的数组 arraysize：数组长度  reversenum：反转个数 /************************************************************************/ void my_reverse( int arr[],  int arraysize,  int reversenum) {     if (reversenum == 0 || reversenum == arraysize) { return; }      for ( int i =  0; i < gcd(reversenum, arraysize); ++i){          int temp = arr[i];          int j = i;          while ( 1){              int k  = j + reversenum;              if (k >= arraysize){ k -= arraysize; }              if (k == i) {  break; }             arr[j] = arr[k]; j = k;         }         arr[j] = temp;     }      return; } int main() {      int a[ 12] = { 'a',  'b',  'c',  'd',  'e',  'f',  'g',  'h',  'i',  'j',  'k',  'l'};      int arraysize  =  12;    // 数组长度      int reversenum =  5;     // 反转个数     my_reverse(a, arraysize, reversenum);      for ( int i =  0; i <  12; ++i)     {         printf( "%c\t", a[i]);     }           return  0; }

 运行结果如下：

心得与疑惑：
1、这里使用了最大公约数的概念，那么最大公约数在算法中有哪些具体应用？为什么这里要使用最大公约数作为置换次数？
2、作者在给出解答是提到了“置换群”的概念？ 怎么去理解它？

作者给出的方案2：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68

#include <cstdio> #include <cstdlib>       // srand, rand #include <ctime>         // time, clock_t #include <cassert>       // assert /************************************************************************/ // 函数名称：my_swap // 函数目的：交换arr[index_a..index_a + swap_num -1]和arr[index_a..index_b + swap_num -1] // 函数参数：arr：要交换的数组 arraysize：数组长度  index_a\index_b:数组索引 //           swap_num:要交换的数目 /************************************************************************/ void my_swap( int arr[],  int arraysize,  int index_a,  int index_b,  int swap_num) {     assert(index_a >=  0 && (index_a+swap_num) <= index_b && (index_b+swap_num) <= arraysize);      for ( int i =  0;  i < swap_num; ++i){          int temp = arr[index_a + i];         arr[index_a + i] = arr[index_b + i]; arr[index_b + i] = temp;     }      return; } /************************************************************************/ // 函数名称：my_reverse // 函数目的：对输入的数组进行反转 // 函数参数：arr：要反转的数组 arraysize：数组长度  reversenum：反转个数 /************************************************************************/ void my_reverse2( int arr[],  int arraysize,  int reversenum) {      if (reversenum ==  0 || reversenum == arraysize) {  return; }      int i, j, p;     i = p = reversenum;     j = arraysize - p;      while ( i != j){          if (i > j){             my_swap(arr, arraysize, p-i, p, j);             i -= j;         }          else {             my_swap(arr, arraysize, p-i, p+j-i, i);             j -= i;         }     }     my_swap(arr, arraysize, p - i, p, j);      return; } int main() {      int a[ 12] = { 'a',  'b',  'c',  'd',  'e',  'f',  'g',  'h',  'i',  'j',  'k',  'l'};      int arraysize  =  12;    // 数组长度      int reversenum =  7;     // 反转个数     // my_reverse(a, arraysize, reversenum);     my_reverse2(a, arraysize, reversenum);      for ( int i =  0; i <  12; ++i)     {         printf( "%c\t", a[i]);     }      return  0; }

数据结果如下：

心得与疑惑：
1、说实话我还是不太怎么理解这个算法，只是依照作者提示，实现了代码！
2、下面是实现过程的分析步骤，帮助理解该算法：
如果arrsize = 5, reversenum=5,那么该程序执行如下：
(1) p = 5, i =5, j = 7
swap(0, 7, 5) 结果： hijkl fg abcde
(2) p = 5, i =5, j = 2
swap(0, 5, 2) 结果： fg jkl hi abcde
(3) p = 5, i =3, j = 2
swap(2, 5, 2) 结果：fg hi l jk abcde
(4) p = 5, i =1, j = 2
swap(4, 6, 1) 结果：fghi k j labcde
(5) p = 5, i =1, j = 1 ---->退出循环
swap(4, 5, 1) 结果：fghi j k labcde

3、作者说该段求解算法 my_reverse2是同求最大公约数的欧几里得算法是同构的，这或许对理解该段代码提供一个很好的思路，如下：  

1 2 3 4 5 6 7 8 9 10

int gcd( int i,  int j) {     assert(i >  0 && j >  0);      while (i != j){          if (i > j) i -= j;          else  j -= i;     }      return i; }

作者给出的方案3：

利用翻转求逆的性质，得到最终的解决方案，该方案是三个中最完美的一个方案。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53

#include <cstdio> #include <cstdlib>       // srand, rand #include <cassert>       // assert /************************************************************************/ // 函数名称：myswap // 函数目的：反转arr索引在[index_a, index_b]之间的值 // 函数参数：arr：要交换的数组 arraysize：数组长度  index_a\index_b:数组索引 /************************************************************************/ void myswap( int* arr,  int arraysize,  int index_a,  int index_b) {     assert(index_a >=  0 && (index_b-index_a) >=  0 && index_b < arraysize);      int i = index_a, j = index_b;      for (;  i <= j; i++, j--){          int temp = *(arr+i);         *(arr+i) = *(arr + j); *(arr + j) = temp;     }      return; } /************************************************************************/ // 函数名称：my_reverse // 函数目的：对输入的数组循环移位进行反转 // 函数参数：arr：要反转的数组 arraysize：数组长度  reversenum：反转个数 /************************************************************************/ void my_reverse3( int* arr,  int arraysize,  int reversenum) {     assert(reversenum <= arraysize);     myswap(arr, arraysize,  0, reversenum- 1);     myswap(arr, arraysize, reversenum, arraysize- 1);     myswap(arr, arraysize,  0, arraysize- 1);      return; } int main() {      int a[ 12] = { 'a',  'b',  'c',  'd',  'e',  'f',  'g',  'h',  'i',  'j',  'k',  'l'};      int arraysize  =  12;    // 数组长度      int reversenum =  6;     // 反转个数     my_reverse3(a, arraysize, reversenum);      for ( int i =  0; i <  12; ++i)     {         printf( "%c\t", a[i]);     }      return  0; }

输出结果如下：

心得与疑惑：

1、求逆：ab->a^r b-> a^r b^r ->(a^r b^r)^r 最为简洁，也最好理解，堪称完美！

2、应该把该代码作为一种常识。