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);
}