Rotate An Array

package jan20;

public class RotateArray {

    public static void main(String[] args) {

        // Initialize array and rotation value
        // Time: O(1), Space: O(1)
        int[] arr = {2, 1, 6, 5, 4, 3};
        int k = 4;
        int len = arr.length;

        // Adjust k if it's greater than length
        // Time: O(1), Space: O(1)
        k = k > len ? k % len : k;

        // Adjust k if negative
        // Time: O(1), Space: O(1)
        k = k < 0 ? k + len : k;

        // Reverse first part of array
        // reverseArray is O(n) where n = len - k
        reverseArray(arr, 0, len - k - 1);

        // Reverse second part of array
        // reverseArray is O(k)
        reverseArray(arr, len - k, len - 1);

        // Reverse whole array
        // reverseArray is O(n)
        reverseArray(arr, 0, len - 1);

        // Print array
        // printArray is O(n)
        printArray(arr);
    }

    private static void reverseArray(int[] arr, int left, int right) {

        // Reversing by swapping
        // Time: O(right - left + 1), Space: O(1) (in-place)
        while (left < right) {
            int temp = arr[left];
            arr[left] = arr[right];
            arr[right] = temp;

            left++;
            right--;
        }
    }

    private static void printArray(int[] arr) {

        // Loop through array
        // Time: O(n), Space: O(1)
        for (int i : arr)
            System.out.print(i + " ");
    }
}

Final Overall:
Operation
Time Complexity
Space Complexity
Rotate array (including 3 reversals)
O(n)
O(1)
Print array
O(n)
O(1)

🔥 Total: O(n) time and O(1) space! Very efficient because everything is done in-place!



Case
Time Complexity
Space Complexity
Explanation
Best Case
O(n)
O(1)
Even if no actual rotation is needed (k = 0 or k = n), still needs 3 full array reversals.
Average Case
O(n)
O(1)
Typically for any k, we reverse parts and whole array → linear time.
Worst Case
O(n)
O(1)
When k is very large (e.g., much bigger than n) — we still normalize k and do 3 reversals on the array.