Given an array arr[] of size N and D index, the task is to rotate the array by the D index.
Left Rotate: Array rotate by D element from left
Example:
Input:
arr[] = {1, 2, 3, 4, 5}
D = 2
Output:
3 4 5 1 2
Explanation: The intial array [1, 2, 3, 4, 5]
rotate by first index [2, 3, 4, 5, 1]
rotate by second index [3, 4, 5, 1, 2]Input:
arr[] = {10, 34, 56, 23, 78, 12, 13, 65}
D = 7
Output:
65 10 34 56 23 78 12 13
- Using temp array
Approach: In this method simply create a temporary array and copy the elements of the array arr[] from 0 to the Dth index. After that move, the rest elements of the array arr[] from index D to N. Then move the temporary array elements to the original array.
Input arr[] = [1, 2, 3, 4, 5], D = 2
1) Store the first d elements in a temp array: temp[] = [1, 2]
2) Shift rest of the arr[]: arr[] = [3, 4, 5]
3) Store back the D elements: arr[] = [3, 4, 5, 1, 2]Below is the implementation of the above approach :
// Java program to left rotate
// an array by D elements
class
GFG {
// Function to left rotate arr[]
// of size N by D
void
leftRotate(
int
arr[],
int
d,
int
n)
{
// create temp array of size d
int
temp[] =
new
int
[d];
// copy first d element in array temp
for
(
int
i =
0
; i < d; i++)
temp[i] = arr[i];
// move the rest element to index
// zero to N-d
for
(
int
i = d; i < n; i++) {
arr[i - d] = arr[i];
}
// copy the temp array element
// in origninal array
for
(
int
i =
0
; i < d; i++) {
arr[i + n - d] = temp[i];
}
}
// utility function to print an array
void
printArray(
int
arr[],
int
n)
{
for
(
int
i =
0
; i < n; i++)
System.out.print(arr[i] +
" "
);
}
// Driver program to test above functions
public
static
void
main(String[] args)
{
GFG rotate =
new
GFG();
int
arr[] = {
1
,
2
,
3
,
4
,
5
};
rotate.leftRotate(arr,
2
, arr.length);
rotate.printArray(arr, arr.length);
}
}
chevron_rightfilter_noneOutput:3 4 5 1 2
Time complexity: O(N)
Auxiliary Space: O(D) -
Rotate one by one:
Approach: Rotate the array recursively one by one element-Input arr[] = [1, 2, 3, 4, 5], D = 2
1) swap arr[0] to arr[1]
2) swap arr[1] to arr[2]
.
.
.
3) swap arr[N-1] to arr[N]
4) Repeat 1, 2, 3 to D timesTo rotate by one, store arr[0] in a temporary variable temp, move arr[1] to arr[0], arr[2] to arr[1] …and finally temp to arr[n-1]
Let us take the same example arr[] = [1, 2, 3, 4, 5], d = 2
Rotate arr[] by one 2 times
We get [2, 3, 4, 5, 1] after first rotation and [ 3, 4, 5, 1, 2] after second rotation.Below is the implementation of the above approach :
// Java program to left rotate
// an array by d elements
class
GFG {
// Function to left rotate arr[]
// of size n by d
void
leftRotate(
int
arr[],
int
d,
int
n)
{
for
(
int
i =
0
; i < d; i++)
leftRotatebyOne(arr, n);
}
void
leftRotatebyOne(
int
arr[],
int
n)
{
int
i, temp;
temp = arr[
0
];
for
(i =
0
; i < n -
1
; i++)
arr[i] = arr[i +
1
];
arr[i] = temp;
}
// utility function to print an array
void
printArray(
int
arr[],
int
n)
{
for
(
int
i =
0
; i < n; i++)
System.out.print(arr[i] +
" "
);
}
// Driver program to test above functions
public
static
void
main(String[] args)
{
GFG rotate =
new
GFG();
int
arr[] = {
1
,
2
,
3
,
4
,
5
};
rotate.leftRotate(arr,
2
, arr.length);
rotate.printArray(arr, arr.length);
}
}
chevron_rightfilter_noneOutput:3 4 5 1 2
Time complexity: O(N * D)
Auxiliary Space: O(1) -
A Juggling Algorithm:
Approach: This is an extension of method 2. Instead of moving one by one, divide the array into different sets where the number of sets is equal to GCD of n and d and move the elements within sets.If GCD is 1 as-is for the above example array (n = 5 and d = 2), then elements will be moved within one set only, we just start with temp = arr[0] and keep moving arr[I+d] to arr[I] and finally store temp at the right place.
Below is the implementation of the above approach :
// Java program to left rotate
// an array by d elements
class
GFG {
// Function to left rotate arr[]
// of siz N by D
void
leftRotate(
int
arr[],
int
d,
int
n)
{
// To handle if d >= n
d = d % n;
int
i, j, k, temp;
int
g_c_d = gcd(d, n);
for
(i =
0
; i < g_c_d; i++) {
// move i-th values of blocks
temp = arr[i];
j = i;
while
(
true
) {
k = j + d;
if
(k >= n)
k = k - n;
if
(k == i)
break
;
arr[j] = arr[k];
j = k;
}
arr[j] = temp;
}
}
// function to print an array
void
printArray(
int
arr[],
int
size)
{
int
i;
for
(i =
0
; i < size; i++)
System.out.print(arr[i] +
" "
);
}
// Function to get gcd of a and b
int
gcd(
int
a,
int
b)
{
if
(b ==
0
)
return
a;
else
return
gcd(b, a % b);
}
// Driver program to test above functions
public
static
void
main(String[] args)
{
GFG rotate =
new
GFG();
int
arr[] = {
1
,
2
,
3
,
4
,
5
};
rotate.leftRotate(arr,
2
, arr.length);
rotate.printArray(arr, arr.length);
}
}
chevron_rightfilter_noneOutput:3 4 5 1 2
Time complexity: O(n)
Auxiliary Space: O(1)
Right Rotate:Array rotate by D element from Right
Example:
Input:
arr[] = {1, 2, 3, 4, 5}
D = 2
Output:
4 5 1 2 3
Explanation:
The intial array [1, 2, 3, 4, 5]
rotate first index [2, 3, 4, 5, 1]
rotate second index [3, 4, 5, 1, 2]
rotate third index [4, 5, 1, 2, 3]Input:
arr[] = {10, 34, 56, 23, 78, 12, 13, 65}
D = 5
Output:
56 23 78 12 13 65 10 34
- Using temp array
Approach: In this method simply create a temporary array and copy the elements of the array arr[] from 0 to the N – D index. After that move, the rest elements of the array arr[] from index D to N. Then move the temporary array elements to the original array.
Input arr[] = [1, 2, 3, 4, 5], D = 2 1) Store the first d elements in a temp array temp[] = [1, 2, 3] 2) Shift rest of the arr[] arr[] = [4, 5] 3) Store back the D elements arr[] = [4, 5, 1, 2, 3]
Below is the implementation of the above approach :
// Java program to rotate an array by
// D elements
class
GFG {
// Function to right rotate arr[]
// of size N by D
void
rightRotate(
int
arr[],
int
d,
int
n)
{
// create temp array of size d
int
temp[] =
new
int
[n - d];
// copy first N-D element in array temp
for
(
int
i =
0
; i < n - d; i++)
temp[i] = arr[i];
// move the rest element to index
// zero to D
for
(
int
i = n - d; i < n; i++) {
arr[i - d -
1
] = arr[i];
}
// copy the temp array element
// in origninal array
for
(
int
i =
0
; i < n - d; i++) {
arr[i + d] = temp[i];
}
}
// utility function to print an array
void
printArray(
int
arr[],
int
n)
{
for
(
int
i =
0
; i < n; i++)
System.out.print(arr[i] +
" "
);
}
// Driver program to test above functions
public
static
void
main(String[] args)
{
GFG rotate =
new
GFG();
int
arr[] = {
1
,
2
,
3
,
4
,
5
};
rotate.rightRotate(arr,
2
, arr.length);
rotate.printArray(arr, arr.length);
}
}
chevron_rightfilter_noneOutput:4 5 1 2 3
Time complexity: O(N)
Auxiliary Space: O(D) -
Rotate one by one:
Approach: Rotate the array recursively one by one element-Input arr[] = [1, 2, 3, 4, 5], D = 2
1) swap arr[N] to arr[N-1]
2) swap arr[N-1] to arr[N-2]
.
.
.
3) swap arr[2] to arr[1]
4) Repeat 1, 2, 3 to D timesTo rotate by one, store arr[N] in a temporary variable temp, move arr[N-1] to arr[N], arr[N-2] to arr[N-1] … and finally temp to arr[1]
Let us take the same example arr[] = [1, 2, 3, 4, 5], d = 2
Rotate arr[] by one 2 times
We get [5, 1, 2, 3, 4] after first rotation and [ 4, 5, 1, 2, 3] after second rotation.Below is the implementation of the above approach :
// Java program to rotate an array by
// d elements
class
GFG {
// Function to right rotate arr[]
// of size n by d
void
rightRotate(
int
arr[],
int
d,
int
n)
{
for
(
int
i = n; i > d; i--)
rightRotatebyOne(arr, n);
}
void
rightRotatebyOne(
int
arr[],
int
n)
{
int
i, temp;
temp = arr[
0
];
for
(i =
0
; i < n -
1
; i++)
arr[i] = arr[i +
1
];
arr[i] = temp;
}
// utility function to print an array
void
printArray(
int
arr[],
int
n)
{
for
(
int
i =
0
; i < n; i++)
System.out.print(arr[i] +
" "
);
}
// Driver program to test above functions
public
static
void
main(String[] args)
{
GFG rotate =
new
GFG();
int
arr[] = {
1
,
2
,
3
,
4
,
5
};
rotate.rightRotate(arr,
2
, arr.length);
rotate.printArray(arr, arr.length);
}
}
chevron_rightfilter_noneOutput:4 5 1 2 3
Time complexity: O(N * D)
Auxiliary Space: O(1) -
A Juggling Algorithm:
Approach: This is an extension of method 2. Instead of moving one by one, divide the array into different sets where the number of sets is equal to GCD of n and d and move the elements within sets.If GCD is 1 as-is for the above example array (n = 5 and d =2), then elements will be moved within one set only, we just start with temp = arr[N] and keep moving arr[I+d] to arr[I] and finally store temp at the right place.
Below is the implementation of the above approach :
// Java program to rotate an array by
// d elements
class
GFG {
// Function to right rotate arr[]
// of siz N by D
void
rightRotate(
int
arr[],
int
d,
int
n)
{
// to use as left rotation
d = n - d;
d = d % n;
int
i, j, k, temp;
int
g_c_d = gcd(d, n);
for
(i =
0
; i < g_c_d; i++) {
// move i-th values of blocks
temp = arr[i];
j = i;
while
(
true
) {
k = j + d;
if
(k >= n)
k = k - n;
if
(k == i)
break
;
arr[j] = arr[k];
j = k;
}
arr[j] = temp;
}
}
// UTILITY FUNCTIONS
// function to print an array
void
printArray(
int
arr[],
int
size)
{
int
i;
for
(i =
0
; i < size; i++)
System.out.print(arr[i] +
" "
);
}
// Function to get gcd of a and b
int
gcd(
int
a,
int
b)
{
if
(b ==
0
)
return
a;
else
return
gcd(b, a % b);
}
// Driver program to test above functions
public
static
void
main(String[] args)
{
GFG rotate =
new
GFG();
int
arr[] = {
1
,
2
,
3
,
4
,
5
};
rotate.rightRotate(arr,
2
, arr.length);
rotate.printArray(arr, arr.length);
}
}
chevron_rightfilter_noneOutput:4 5 1 2 3
Time complexity: O(n)
Auxiliary Space: O(1)
Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.