Algorithms - Circular Array Rotation

No.

Consider this example.

#include <iostream>

int main(void) {
    int n = 6;
    int k = 2;
    int a[] = {1, 2, 3, 4, 5, 6};

    int write_to     = 0;
    int copy_current = 0;
    int copy_final   = a[0];
    int rotation     = k;
    int position     = 0;

    for (int i = 0; i < n; i++) {
        write_to     = (position + rotation) % n;
        copy_current = a[write_to];
        a[write_to]  = copy_final;
        position     = write_to;
        copy_final   = copy_current;
     }

    for (int i = 0; i < n; i++) {
        std::cout << a[i] << (i + 1 < n ? ' ' : '\n');
    }
    return 0;
}

Expected result:

5 6 1 2 3 4

Actual result:

3 2 1 4 1 6

Using stl::rotate on std::array, you can left rotate by, say 2, as:

std::array<int, 6> a{1, 2, 3, 4, 5, 6};
std::rotate(begin(a), begin(a) + 2, end(a)); // left rotate by 2

to yield: 3 4 5 6 1 2, or right-rotate by, say 2, as:

std::rotate(begin(a), end(a) - 2, end(a)); // right rotate by 2

to yield: 5 6 1 2 3 4, with linear complexity.

Rotate an Array of length n for k times in left or right directions.

The code is in Java

I define a Direction Enum:

public enum Direction {
    L, R
};

Rotation with times and direction:

public static final void rotate(int[] arr, int times, Direction direction) {
    if (arr == null || times < 0) {
        throw new IllegalArgumentException("The array must be non-null and the order must be non-negative");
    }
    int offset = arr.length - times % arr.length;
    if (offset > 0) {
        int[] copy = arr.clone();
        for (int i = 0; i < arr.length; ++i) {
            int j = (i + offset) % arr.length;
            if (Direction.R.equals(direction)) {
                arr[i] = copy[j];
            } else {
                arr[j] = copy[i];
            }
        }
    }
}

Complexity: O(n).

Example: Input: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] Rotate 3 times left Output: [4, 5, 6, 7, 8, 9, 10, 1, 2, 3]

Input: [4, 5, 6, 7, 8, 9, 10, 1, 2, 3] Rotate 3 times right Output: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]