[GeeksForGeeks] Cyclically rotate an array by one

Given an array of integers, write a program that cyclically rotates the array by one.

Example: given {1,2,3,4,5}, your program should rotate the array to {5,1,2,3,4}

Algorithm:

1. save the last element in a temp variable.

2. starting from the last element until the second element, copy its previous element to be their values.

3. copy temp to the first element.

O(n) runtime, O(1) space

public void rotateByOne(int[] arr) {
    if(arr == null || arr.length == 0){
        return;
    }
    int temp = arr[arr.length - 1];
    for(int i = arr.length - 1; i > 0; i--){
        arr[i] = arr[i - 1];
    }
    arr[0] = temp;
}

Follow up question:  instead of rotating the given array by one position, rotate it by m positions, m should be controlled by 

your program caller. if m is positive, it means rotating right, if m is negative, it means rotating left.

Solution 1. O(m * n) runtime

Simply call rotateByOne m times.

Solution 2. O(n) runtime, O(1) space

Algorithm:  Acheive the rotation by swaping values only one time instead of  m times for each location.

1. Move arr[0] to a temporary variable t, then move arr[m] to arr[0], arr[2 * m] to arr[m], and so on.(taking all indices into arr modulo arr.length), until we come back to taking the element from arr[0], 

    at which point we instead take t and stop the process.

2. If step 1 does not move all the elements, repeat step 1 starting from arr[1].  Repeat this step until all the elements are moved, advancing the start element to the next location each iteration.

The following code only shows the left rotation implementation, the right counter part is similar.

public static void leftRotateByM(int[] arr, int m) {
    if(m % arr.length != 0) {
        int count = 0;
        int startIdx = 0;                   
        while(count < arr.length) {
            int currIdx = startIdx;
            int nextIdx = (currIdx + m) % arr.length;
            int temp = arr[startIdx];
            while(nextIdx != startIdx) {
                arr[currIdx] = arr[nextIdx];
                currIdx = nextIdx;
                nextIdx = (nextIdx + m) % arr.length;
                count++;
            }
            arr[currIdx] = temp;
            startIdx++;
            count++;
        }
    }
}

Solution 3. O(n) runtime, O(1) space, using reverse algorithm

1. decide on the split point depending if it is a left or right rotation.

2. reverse the splitted array separately, then reverse the whole array.

private void reverse(int[] arr, int start, int end) {
    while(start < end) {
        arr[start] ^= arr[end];
        arr[end] ^= arr[start];
        arr[start] ^= arr[end];
        start++;
        end--;
    }
}
public void rotateByMUsingReverse(int[] arr, int m) {
    if(arr == null || arr.length == 0 || m % arr.length == 0){
        return;
    }
    m %= arr.length;
    int splitIdx = m > 0 ? arr.length - m : m;
    reverse(arr, 0, splitIdx - 1);
    reverse(arr, splitIdx, arr.length - 1);
    reverse(arr, 0, arr.length - 1);
}