Array Rotation in Java

In this section, we will learn what is rotation of an array and how to rotate an array in through a Java program.

Java Array Rotation

The rotation of an array simply means to shift the array elements of an array to the specified positions. We can rotate an array in both directions i.e. clockwise and anti-clockwise. We can perform any number of rotations on an array.

Types of Rotation

Left Rotation
Right Rotation

Left Rotation

In left rotation, the array elements rotated to the left with the specified number of positions. It rotates the array in the clockwise direction. The lowest index element moves to the highest index in rotation.

Example

Suppose, [1, 2, 3, 4, 5] is an array and we need to perform 2 left rotations on an array then the array become:

Given array = [1, 2, 3, 4, 5]

Array after first left rotation = [2, 3, 4, 5, 1]

Array after second left rotation = [3, 4, 5, 1, 2]

ArrayLeftRotation.java

public class ArrayLeftRotation
{
//function that rotates (left) the array of size n by d
public static void rotateLeft(int array[], int d, int n) 
{ 
for (int i = 0; i < d; i++) 
//calling function without passing the number of rotations
rotateArrayByOne(array, n); 
} 
public static void rotateArrayByOne(int array[], int n) 
{ 
int i, temp; 
//temporary array to store the newly created array
temp = array[0]; 
for (i = 0; i < n - 1; i++) 
//shifts array element to the left by 1
array[i] = array[i + 1];
array[i] = temp; 
} 
public static void main(String args[]) 
{ 
//array to rotate
int array[] = { 11, 22, 33, 44, 55, 66, 77 }; 
//number of rotations to be performed
//we can change the number of rotations accordingly
int r = 1;
//determines the length of array
int n = array.length;
System.out.println("Array before rotation: "); 
for(int i = 0 ; i < n ; i++)
{
//prints array before rotation
System.out.print(array[i]+ " "); 
}
System.out.println();
rotateLeft(array, r, n); 
System.out.println("\nArray after left rotation: "); 
for(int i = 0 ; i < n ; i++)
{
//prints array after performing rotation    
System.out.print(array[i] + " ");
} 
} 
}

Output:

Right Rotation

In the right rotation, the array elements rotated to the right with the specified number of positions. It rotates the array in an anti-clockwise direction.

Example:

Suppose [4, 7, 9, 0, 1] is an array and we need to perform 2 left rotations on an array then the array become:

Given array = [4, 7, 9, 0, 1]

Array after first left rotation = [1, 4, 7, 9, 0]

Array after second left rotation = [0, 1, 4, 7, 9]

ArrayRightRotation.java

public class ArrayRightRotation
{
//function that rotates (right) the array of size n by d
public static void rotateRight(int array[], int d, int n) 
{ 
for (int i = 0; i < d; i++) 
//calling function without passing the number of rotations
rotateArrayByOne(array, n);    
}  
public static void rotateArrayByOne(int array[], int n) 
{ 
int i, temp; 
//temporary array to store the newly created array
temp = array[n - 1]; 
for (i = n-1; i > 0; i--) 
//shifts array element to the left by 1
array[i] = array[i - 1];     
array[0] = temp; 
} 
public static void main(String args[]) 
{ 
//array to rotate
int array[] = { 12, -9, 45, 23, -99, 67, 98, 90, 11, 45}; 
//number of rotations to be performed
//we can change the number of rotations accordingly
int r = 3;
//determines the length of array
int n = array.length;
System.out.println("Array before rotation: "); 
for(int i = 0 ; i < n ; i++)
{
//prints array before rotation
System.out.print(array[i]+ " "); 
}
System.out.println();
rotateRight(array, r, n); 
System.out.println("\nArray after right rotation: "); 
for(int i = 0 ; i < n ; i++)
{
//prints array after performing rotation    
System.out.print(array[i] + " ");
} 
} 
}

Output:

How to rotate an array?

There are the following four ways to rotate an array:

Using Temp Array
Rotate Element One by One
By Using Juggling Algorithm
By Reversing an Array

Using Temp Array

Input array[] = [11, 22, 33, 44, 55], Number of rotations (r) = 2, Number of elements (n) = 5

1. Store the first r elements in a temp array.

2. Move rest array to the left.

3. After that, append the element of the temparray[] to the array[].

Rotate Element One by One

rotateLeft(array[], r, n)
start
  	For i = 0 to i < r
    	Rotate left all the elements of array[] by 1
end

By Using Juggling Algorithm

Juggling algorithm is the advanced version of the second (rotate element one by one) approach. The algorithm divides the whole array into different sets. We can find the number of sets by finding the GCD of r and n. After getting the sets, move the elements within the sets. Let's understand the algorithm through an example.

Suppose, a[] is an array having 12 (n) elements (1, 2, 3,……, 12) and we need to perform 3 (d) rotations, then according to the algorithm:

GCD of n and d = 3

Elements are first moved in the first set. After the movement, we get the following array:

{4, 2, 3, 7, 5, 6, 10, 8, 9, 1, 11, 12}

Movement of elements in second set.

{4, 5, 3, 7, 8, 6, 10, 11, 9, 1, 2, 12}

At last, movement of elements in third set.

{4, 5, 6, 7, 8, 9, 10, 11, 12, 1, 2, 3}

Let's implement the above approach in a Java program.

JugglingAlgo.java

public class ArrayRotateLeft 
{
//function that rotates (left) the array of size n by d
void rotateLeft(int array[], int d, int n) 
{ 
//execuute if d >= n
d = d % n; 
int i, j, k, temp; 
//calling gcd() function to determine the GCD of n and d
int gcd = gcd(d, n); 
for (i = 0; i < gcd; i++) 
{ 
//moves the i-th values of the blocks
temp = array[i]; 
j = i; 
while (true) 
{ 
k = j + d; 
if (k >= n) 
k = k - n; 
if (k == i) 
break; 
array[j] = array[k]; 
j = k; 
} 
array[j] = temp; 
} 
} 
//function to print array
void printArray(int array[], int size) 
{ 
for (int i = 0; i < size; i++) 
System.out.print(array[i] + " "); 
} 
//function to determine the GCD of a nd b
int gcd(int a, int b) 
{ 
if (b == 0) 
return a; 
else
return gcd(b, a % b); 
} 
public static void main(String args[]) 
{ 
ArrayRotateLeft  arf = new ArrayRotateLeft(); 
//array to rotate
int array[] = {19, 25, 22, 67, -90, 77, -11, -20, 76}; 
System.out.println("Array before rotation: "); 
arf.printArray(array, 9);
System.out.println("\n"); 
arf.rotateLeft(array, 2, 9); 
System.out.println("Array after left rotation: "); 
arf.printArray(array, 9); 
} 
} 

Output:

By Reversing an Array

The idea is to reverse the last k elements of the input array and then reverse the remaining n-k elements. Using the mechanism, we get the right rotated array by reversing the complete array.

RotateReverse.java

import java.util.Arrays;
public class RotateArrayRight
{
//function to swap array elements
public static void swapElement(int[] array, int i, int j)
{
int temp = array[i];
array[i] = array[j];
array[j] = temp;
}
//function to reverse a given subarray
public static void reverseArray(int[] array, int low, int high)
{
for (int i = low, j = high; i < j; i++, j--) 
{
swapElement(array, i, j);
}
}
//function to rotate array to the right by k positions
public static void rotateRight(int[] array, int k, int n)
{
//reverse the last k elements
reverseArray(array, n - k, n - 1);
//reverse the first n-k elements
reverseArray(array, 0, n - k - 1);
//reverse the complete array
reverseArray(array, 0, n - 1);
}
public static void main(String args[])
{
//array to rotate
int[] array = {111, 786, 908, 209, 567, 232, 665};
//k denotes the position to shift 
int k = 3;
System.out.println("Array before rotation: ");
System.out.println(Arrays.toString(array));
System.out.println();
System.out.println("Array after right rotation: ");
rotateRight(array, k, array.length);
System.out.println(Arrays.toString(array));
}
}

Output: