A very efficient and economical way to shift an array

 How do you shift an array? For example, there is an array {a, b, c, d, 1, 2, 3, 4}, and the requirement is to cyclic-shift 3 elements to the right. That means, after the shift, the array looks like this: {2, 3, 4, a, b, c, d, 1}. This problem is so easy that most people can solve it in just one or two minutes, or even less time. However, here introduces another interesting way to shoot it, which uses reversing and is very economical in both time and space usage. The above example is used again to illustrate the whole process. Totally we need 2 times of reversing. The first time, we reverse the two subarrays with (n-k) and k elements respectively, that is {a, b, c, d, 1, 2, 3, 4} --> {1, d, c, b, a, 4, 3, 2}; the second time, we reverse the whole new array, that is {1, d, c, b, a, 4, 3, 2} --> {2, 3, 4, a, b, c, d, 1}. Job done. So interesting, efficient and economical, right? Below is one implementation.

1. #include <iostream>
2. using namespace std;
4. template <typename T>
5. void array_print(T* array, int n) {
6.     for(int i = 0; i < n; ++i) {
7.         cout << array[i] << " ";
8.     }
9.     cout << endl;
10. }
12. template <typename T>
13. T* array_shift(T* array, int n, int k) {
14.     k %= n;
15.     if(k == 0) {
16.         return array;
17.     }
18.     int temp;
19.     // Reverse the left subarray with (n-k) elements.
20.     for(int i = 0; i < (n-k)/2; ++i) {
21.         temp = array[i];
22.         array[i] = array[n-k-1-i];
23.         array[n-k-1-i] = temp;
24.     }
25.     // Reverse the right subarray with k elements.
26.     for(int i = 0; i < k/2; ++i) {
27.         temp = array[(n-k)+i];
28.         array[(n-k)+i] = array[(n-1)-i];
29.         array[(n-1)-i] = temp;
30.     }
31.     // Reverse the whole array.
32.     for(int i = 0; i < n/2; ++i) {
33.         temp = array[i];
34.         array[i] = array[n-1-i];
35.         array[n-1-i] = temp;
36.     }
37.     return array;
38. }
40. int main() {
41.     int ia[10] = {1,3,5,7,9,2,4,6,8,10};
42.     array_print(array_shift(ia, 10, 7), 10);
43.     char ca[8] = {'a','b','c','d','1','2','3','4'};
44.     array_print(array_shift(ca, 8, 4), 8);
45.     array_print(array_shift(ca, 8, 4), 8);
46.     array_print(array_shift(ca, 8, 5), 8);
47.     return 0;
48. }

The command line prints:

7 9 2 4 6 8 10 1 3 5

1 2 3 4 a b c d

a b c d 1 2 3 4

d 1 2 3 4 a b c

 

Referenced to <Beauty of Programming>.