Write a function rotate(arr[], d, n) that rotates arr[] of size n by d elements.

Rotation of the above array by 2 will make an array

Algorithm :
Initialize A = arr[0..d-1] and B = arr[d..n-1]
1) Do following until size of A is equal to size of B
a) If A is shorter, divide B into Bl and Br such that Br is of same
length as A. Swap A and Br to change ABlBr into BrBlA. Now A
is at its final place, so recur on pieces of B.
b) If A is longer, divide A into Al and Ar such that Al is of same
length as B Swap Al and B to change AlArB into BArAl. Now B
is at its final place, so recur on pieces of A.
2) Finally when A and B are of equal size, block swap them.
Recursive Implementation:
C++
#include <bits/stdc++.h>
using namespace std;
#include <bits/stdc++.h>
using namespace std;
void printArray( int arr[], int size)
{
int i;
for (i = 0; i < size; i++)
cout << arr[i] << " " ;
cout << endl;
}
void swap( int arr[], int fi, int si, int d)
{
int i, temp;
for (i = 0; i < d; i++) {
temp = arr[fi + i];
arr[fi + i] = arr[si + i];
arr[si + i] = temp;
}
}
void leftRotate( int arr[], int d, int n)
{
if (d == 0 || d == n)
return ;
if (d > n)
d = d % n;
if (n - d == d) {
swap(arr, 0, n - d, d);
return ;
}
if (d < n - d) {
swap(arr, 0, n - d, d);
leftRotate(arr, d, n - d);
}
else
{
swap(arr, 0, d, n - d);
leftRotate(arr + n - d, 2 * d - n,
d);
}
}
int main()
{
int arr[] = { 1, 2, 3, 4, 5, 6, 7 };
leftRotate(arr, 2, 7);
printArray(arr, 7);
return 0;
}
|
C
#include<stdio.h>
void printArray( int arr[], int size);
void swap( int arr[], int fi, int si, int d);
void leftRotate( int arr[], int d, int n)
{
if (d == 0 || d == n)
return ;
if (n-d == d)
{
swap(arr, 0, n-d, d);
return ;
}
if (d < n-d)
{
swap(arr, 0, n-d, d);
leftRotate(arr, d, n-d);
}
else
{
swap(arr, 0, d, n-d);
leftRotate(arr+n-d, 2*d-n, d);
}
}
void printArray( int arr[], int size)
{
int i;
for (i = 0; i < size; i++)
printf ( "%d " , arr[i]);
printf ( "\n " );
}
void swap( int arr[], int fi, int si, int d)
{
int i, temp;
for (i = 0; i<d; i++)
{
temp = arr[fi + i];
arr[fi + i] = arr[si + i];
arr[si + i] = temp;
}
}
int main()
{
int arr[] = {1, 2, 3, 4, 5, 6, 7};
leftRotate(arr, 2, 7);
printArray(arr, 7);
getchar ();
return 0;
}
|
Java
import java.util.*;
class GFG
{
public static void leftRotate( int arr[], int d,
int n)
{
leftRotateRec(arr, 0 , d, n);
}
public static void leftRotateRec( int arr[], int i,
int d, int n)
{
if (d == 0 || d == n)
return ;
if (n - d == d)
{
swap(arr, i, n - d + i, d);
return ;
}
if (d < n - d)
{
swap(arr, i, n - d + i, d);
leftRotateRec(arr, i, d, n - d);
}
else
{
swap(arr, i, d, n - d);
leftRotateRec(arr, n - d + i, 2 * d - n, d);
}
}
public static void printArray( int arr[], int size)
{
int i;
for (i = 0 ; i < size; i++)
System.out.print(arr[i] + " " );
System.out.println();
}
public static void swap( int arr[], int fi,
int si, int d)
{
int i, temp;
for (i = 0 ; i < d; i++)
{
temp = arr[fi + i];
arr[fi + i] = arr[si + i];
arr[si + i] = temp;
}
}
public static void main (String[] args)
{
int arr[] = { 1 , 2 , 3 , 4 , 5 , 6 , 7 };
leftRotate(arr, 2 , 7 );
printArray(arr, 7 );
}
}
|
Python3
def leftRotate(arr, d, n):
leftRotateRec(arr, 0 , d, n);
def leftRotateRec(arr, i, d, n):
if (d = = 0 or d = = n):
return ;
if (n - d = = d):
swap(arr, i, n - d + i, d);
return ;
if (d < n - d):
swap(arr, i, n - d + i, d);
leftRotateRec(arr, i, d, n - d);
else :
swap(arr, i, d, n - d);
leftRotateRec(arr, n - d + i, 2 * d - n, d);
def printArray(arr, size):
for i in range (size):
print (arr[i], end = " " );
print ();
def swap(arr, fi, si, d):
for i in range (d):
temp = arr[fi + i];
arr[fi + i] = arr[si + i];
arr[si + i] = temp;
if __name__ = = '__main__' :
arr = [ 1 , 2 , 3 , 4 , 5 , 6 , 7 ];
leftRotate(arr, 2 , 7 );
printArray(arr, 7 );
|
C#
using System;
class GFG{
public static void leftRotate( int []arr,
int d, int n)
{
leftRotateRec(arr, 0, d, n);
}
public static void leftRotateRec( int []arr, int i,
int d, int n)
{
if (d == 0 || d == n)
return ;
if (n - d == d)
{
swap(arr, i, n - d + i, d);
return ;
}
if (d < n - d)
{
swap(arr, i, n - d + i, d);
leftRotateRec(arr, i, d, n - d);
}
else
{
swap(arr, i, d, n - d);
leftRotateRec(arr, n - d + i,
2 * d - n, d);
}
}
public static void printArray( int []arr,
int size)
{
int i;
for (i = 0; i < size; i++)
Console.Write(arr[i] + " " );
Console.WriteLine();
}
public static void swap( int []arr, int fi,
int si, int d)
{
int i, temp;
for (i = 0; i < d; i++)
{
temp = arr[fi + i];
arr[fi + i] = arr[si + i];
arr[si + i] = temp;
}
}
public static void Main(String[] args)
{
int []arr = { 1, 2, 3, 4, 5, 6, 7 };
leftRotate(arr, 2, 7);
printArray(arr, 7);
}
}
|
Javascript
<script>
let leftRotate = (arr, d, n) =>{
if (d == 0 || d == n)
return ;
if (n - d == d) {
arr = swap(arr, 0, n - d, d);
return ;
}
if (d < n - d) {
arr = swap(arr, 0, n - d, d);
leftRotate(arr, d, n - d);
}
else {
arr = swap(arr, 0, d, n - d);
leftRotate(arr + n - d, 2 * d - n, d);
}
}
let printArray = (arr, size) =>{
ans = ''
for (let i = 0; i < size; i++)
ans += arr[i]+ " " ;
document.write(ans)
}
let swap = (arr, fi, si, d) =>{
for (let i = 0; i < d; i++) {
let temp = arr[fi + i];
arr[fi + i] = arr[si + i];
arr[si + i] = temp;
}
return arr
}
arr = [1, 2, 3, 4, 5, 6, 7];
leftRotate(arr, 2, 7);
printArray(arr, 7);
</script>
|
Time Complexity: O(n)
Auxiliary Space: O(log n)
Iterative Implementation:
Here is an iterative implementation of the same algorithm. The same utility function swap() is used here.
C++
#include <bits/stdc++.h>
using namespace std;
void printArray( int arr[], int size)
{
int i;
for (i = 0; i < size; i++)
cout << arr[i] << " " ;
cout << endl;
}
void swap( int arr[], int fi, int si, int d)
{
int i, temp;
for (i = 0; i < d; i++) {
temp = arr[fi + i];
arr[fi + i] = arr[si + i];
arr[si + i] = temp;
}
}
void leftRotate( int arr[], int d, int n)
{
int i, j;
if (d == 0 || d == n)
return ;
if (d > n)
d = d % n;
i = d;
j = n - d;
while (i != j) {
if (i < j)
{
swap(arr, d - i, d + j - i, i);
j -= i;
}
else
{
swap(arr, d - i, d, j);
i -= j;
}
}
swap(arr, d - i, d, i);
}
int main()
{
int arr[] = { 1, 2, 3, 4, 5, 6, 7 };
leftRotate(arr, 2, 7);
printArray(arr, 7);
return 0;
}
|
C
#include <stdio.h>
void printArray( int arr[], int size)
{
int i;
for (i = 0; i < size; i++)
printf ( "%d " , arr[i]);
printf ( "\n " );
}
void swap( int arr[], int fi, int si, int d)
{
int i, temp;
for (i = 0; i < d; i++) {
temp = arr[fi + i];
arr[fi + i] = arr[si + i];
arr[si + i] = temp;
}
}
void leftRotate( int arr[], int d, int n)
{
int i, j;
if (d == 0 || d == n)
return ;
if (d > n)
d = d % n;
i = d;
j = n - d;
while (i != j) {
if (i < j)
{
swap(arr, d - i, d + j - i, i);
j -= i;
}
else
{
swap(arr, d - i, d, j);
i -= j;
}
}
swap(arr, d - i, d, i);
}
int main()
{
int arr[] = { 1, 2, 3, 4, 5, 6, 7 };
leftRotate(arr, 2, 7);
printArray(arr, 7);
getchar ();
return 0;
}
|
Java
import java.io.*;
public class GFG {
static void leftRotate( int arr[], int d, int n)
{
int i, j;
if (d == 0 || d == n)
return ;
if (d > n)
d = d % n;
i = d;
j = n - d;
while (i != j) {
if (i < j)
{
swap(arr, d - i, d + j - i, i);
j -= i;
}
else
{
swap(arr, d - i, d, j);
i -= j;
}
}
swap(arr, d - i, d, i);
}
public static void printArray( int arr[], int size)
{
int i;
for (i = 0 ; i < size; i++)
System.out.print(arr[i] + " " );
System.out.println();
}
public static void swap( int arr[], int fi, int si,
int d)
{
int i, temp;
for (i = 0 ; i < d; i++) {
temp = arr[fi + i];
arr[fi + i] = arr[si + i];
arr[si + i] = temp;
}
}
public static void main(String[] args)
{
int arr[] = { 1 , 2 , 3 , 4 , 5 , 6 , 7 };
leftRotate(arr, 2 , 7 );
printArray(arr, 7 );
}
}
|
Python3
def printArray(arr, size):
for i in range (size):
print (arr[i], end = " " )
print ()
def swap(arr, fi, si, d):
for i in range (d):
temp = arr[fi + i]
arr[fi + i] = arr[si + i]
arr[si + i] = temp
def leftRotate(arr, d, n):
if (d = = 0 or d = = n):
return
i = d
j = n - d
while (i ! = j):
if (i < j):
swap(arr, d - i, d + j - i, i)
j - = i
else :
swap(arr, d - i, d, j)
i - = j
swap(arr, d - i, d, i)
if __name__ = = '__main__' :
arr = [ 1 , 2 , 3 , 4 , 5 , 6 , 7 ]
leftRotate(arr, 2 , 7 )
printArray(arr, 7 )
|
C#
using System;
class GFG {
public static void printArray( int [] arr, int size)
{
int i;
for (i = 0; i < size; i++)
Console.Write(arr[i] + " " );
Console.WriteLine();
}
public static void swap( int [] arr, int fi, int si,
int d)
{
int i, temp;
for (i = 0; i < d; i++) {
temp = arr[fi + i];
arr[fi + i] = arr[si + i];
arr[si + i] = temp;
}
}
static void leftRotate( int [] arr, int d, int n)
{
int i, j;
if (d == 0 || d == n)
return ;
if (d > n)
d = d % n;
i = d;
j = n - d;
while (i != j) {
if (i < j)
{
swap(arr, d - i, d + j - i, i);
j -= i;
}
else
{
swap(arr, d - i, d, j);
i -= j;
}
}
swap(arr, d - i, d, i);
}
public static void Main(String[] args)
{
int [] arr = { 1, 2, 3, 4, 5, 6, 7 };
leftRotate(arr, 2, 7);
printArray(arr, 7);
}
}
|
Javascript
<script>
function leftRotate(arr, d, n)
{
if (d == 0 || d == n)
return ;
let i = d;
let j = n - d;
while (i != j)
{
if (i < j)
{
arr = swap(arr, d - i, d + j - i, i);
j -= i;
}
else {
arr = swap(arr, d - i, d, j);
i -= j;
}
}
arr = swap(arr, d - i, d, i);
}
</script>
|
Time Complexity: O(n)
Auxiliary Space: O(1)
Please see the following posts for other methods of array rotation:
https://www.geeksforgeeks.org/array-rotation/
https://www.geeksforgeeks.org/program-for-array-rotation-continued-reversal-algorithm/
Please write comments if you find any bug in the above programs/algorithms or want to share any additional information about the block swap algorithm.
Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!
Last Updated :
20 Jul, 2023
Like Article
Save Article