n元一维向量向左循环移位i的几种算法

1、最简单的算法借助于一个n元的中间向量在n步时间内完成

时间复杂度：O(n)  空间复杂度O(n)

 void shift_easy(int arr[], int _arr[], int n, int i){
     int j = ;     while(i < n){
         _arr[j++] = arr[i++];
     }
     i = ;
     while(j < n){
         _arr[j++] = arr[i++];
     } }

2、使用翻转的思路完成一个不需要额外空间、编写简单并且实际运行很快的算法

时间复杂度：O(n)

 void swap(int arr[], int i, int j){
     int temp;
     temp = arr[i];
     arr[i] = arr[j];
     arr[j] = temp;
 } void reverse_shift(int arr[], int n, int i){
     int j , k;     j = ;
     while(j < (i - j - )){
         swap(arr, j, i- j- );
         j++;
     }
     j = i;
     k = ;
     while(j < (n - k - )){
         swap(arr, j, n - k -);
         j++;
         k++;
     }
     j=;
     while(j < (n - j - )){
         swap(arr, j, n - j -);
         j++;
     }
 }

3、在O(n)时间内完成、不需要额外空间的杂技算法

原理是：将x[0]移动到t，将x[i]移动到x[0]，将x[2i]移动到x[i]（将x的下标对n取模），直到返回取x[0]中的元素，此时改为从t取值并停止过程。如果该过程没有移动全部元素，就从x[1]开始再次移动，直到所有的元素都移动为止。

 int gcd(int a, int b){
     int temp;
     if(b == )
         return a;
     do{
         temp = a % b;
         a = b;
         b = temp;
     }while(b != );
     return a;
 } void acrob_shift(int arr[], int n, int rotdist){
     int j, k, i, temp;     for(i = ; i < gcd(rotdist, n); i++){
         temp = arr[i];
         j = i;
         while(){
             k = j + rotdist;
             if(k >= n)
                 k -= n;
             if(k == i)
                 break;
             arr[j] = arr[k];
             j = k;
         }
         arr[j] = temp;
     }
 }

4、块交换算法（效率最高）

 void swap_block(int arr[], int sp1, int sp2, int s){
     int temp;
     while(s > ){
         temp = arr[sp1 + s -];
         arr[sp1 + s - ] = arr[sp2 + s - ];
         arr[sp2 + s - ] = temp;
         s--;
     }
 } void block_shift(int arr[], int n, int rotdist){
     int i, j, p;
     if(rotdist ==  || rotdist == n)
         return;
     i = p = rotdist;
     j = n - p;
     while(i != j){
         if(i > j){
             swap_block(arr, p-i, p, j);
             i -= j;
         }
         else{
             swap_block(arr, p-i, p+j-i, i);
             j -= i;
         }
     }
     swap_block(arr, p-i, p, i);
 }