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

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

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

void shift_easy(int arr[], int _arr[], int n, int i){
    int j = 0;

    while(i < n){
        _arr[j++] = arr[i++];
    }
    i = 0;
    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 = 0;
    while(j < (i - j - 1)){
        swap(arr, j, i- j- 1);
        j++;
    }
    j = i;
    k = 0;
    while(j < (n - k - 1)){
        swap(arr, j, n - k -1);
        j++;
        k++;
    }
    j=0;
    while(j < (n - j - 1)){
        swap(arr, j, n - j -1);
        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 == 0)
        return a;
    do{
        temp = a % b;
        a = b;
        b = temp;
    }while(b != 0);
    return a;
}

void acrob_shift(int arr[], int n, int rotdist){
    int j, k, i, temp;

    for(i = 0; i < gcd(rotdist, n); i++){
        temp = arr[i];
        j = i;
        while(1){
            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 > 0){
        temp = arr[sp1 + s -1];
        arr[sp1 + s - 1] = arr[sp2 + s - 1];
        arr[sp2 + s - 1] = temp;
        s--;
    }
}

void block_shift(int arr[], int n, int rotdist){
    int i, j, p;
    if(rotdist == 0 || 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);
}