Block swap algorithm for array rotation
Last Updated :
20 Jul, 2023
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;
/*UTILITY FUNCTIONS*/
/* function to print an array */
void printArray(int arr[], int size)
{
int i;
for (i = 0; i < size; i++)
cout << arr[i] << " ";
cout << endl;
}
/*This function swaps d elements starting at index fi
with d elements starting at index si */
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)
{
/* Return If number of elements to be rotated
is zero or equal to array size */
if (d == 0 || d == n)
return;
/* If number of elements to be rotated is more than
* array size*/
if (d > n)
d = d % n;
/*If number of elements to be rotated
is exactly half of array size */
if (n - d == d) {
swap(arr, 0, n - d, d);
return;
}
/* If A is shorter*/
if (d < n - d) {
swap(arr, 0, n - d, d);
leftRotate(arr, d, n - d);
}
else /* If B is shorter*/
{
swap(arr, 0, d, n - d);
leftRotate(arr + n - d, 2 * d - n,
d); /*This is tricky*/
}
}
// Driver Code
int main()
{
int arr[] = { 1, 2, 3, 4, 5, 6, 7 };
leftRotate(arr, 2, 7);
printArray(arr, 7);
return 0;
}
// This code is contributed by rathbhupendra
#include<stdio.h>
/*Prototype for utility functions */
void printArray(int arr[], int size);
void swap(int arr[], int fi, int si, int d);
void leftRotate(int arr[], int d, int n)
{
/* Return If number of elements to be rotated is
zero or equal to array size */
if(d == 0 || d == n)
return;
/*If number of elements to be rotated is exactly
half of array size */
if(n-d == d)
{
swap(arr, 0, n-d, d);
return;
}
/* If A is shorter*/
if(d < n-d)
{
swap(arr, 0, n-d, d);
leftRotate(arr, d, n-d);
}
else /* If B is shorter*/
{
swap(arr, 0, d, n-d);
leftRotate(arr+n-d, 2*d-n, d); /*This is tricky*/
}
}
/*UTILITY FUNCTIONS*/
/* function to print an array */
void printArray(int arr[], int size)
{
int i;
for(i = 0; i < size; i++)
printf("%d ", arr[i]);
printf("\n ");
}
/*This function swaps d elements starting at index fi
with d elements starting at index si */
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;
}
}
/* Driver program to test above functions */
int main()
{
int arr[] = {1, 2, 3, 4, 5, 6, 7};
leftRotate(arr, 2, 7);
printArray(arr, 7);
getchar();
return 0;
}
import java.util.*;
class GFG
{
// Wrapper over the recursive function leftRotateRec()
// It left rotates arr[] by d.
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)
{
/* Return If number of elements to be rotated
is zero or equal to array size */
if(d == 0 || d == n)
return;
/*If number of elements to be rotated
is exactly half of array size */
if(n - d == d)
{
swap(arr, i, n - d + i, d);
return;
}
/* If A is shorter*/
if(d < n - d)
{
swap(arr, i, n - d + i, d);
leftRotateRec(arr, i, d, n - d);
}
else /* If B is shorter*/
{
swap(arr, i, d, n - d);
leftRotateRec(arr, n - d + i, 2 * d - n, d); /*This is tricky*/
}
}
/*UTILITY FUNCTIONS*/
/* function to print an array */
public static void printArray(int arr[], int size)
{
int i;
for(i = 0; i < size; i++)
System.out.print(arr[i] + " ");
System.out.println();
}
/*This function swaps d elements
starting at index fi with d elements
starting at index si */
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;
}
}
// Driver Code
public static void main (String[] args)
{
int arr[] = {1, 2, 3, 4, 5, 6, 7};
leftRotate(arr, 2, 7);
printArray(arr, 7);
}
}
// This code is contributed by codeseeker
# Wrapper over the recursive function leftRotateRec()
# It left rotates arr by d.
def leftRotate(arr, d, n):
leftRotateRec(arr, 0, d, n);
def leftRotateRec(arr, i, d, n):
'''
* Return If number of elements to be
rotated is zero or equal to array size
'''
if (d == 0 or d == n):
return;
'''
* If number of elements to be rotated
is exactly half of array size
'''
if (n - d == d):
swap(arr, i, n - d + i, d);
return;
''' If A is shorter '''
if (d < n - d):
swap(arr, i, n - d + i, d);
leftRotateRec(arr, i, d, n - d);
''' If B is shorter '''
else:
swap(arr, i, d, n - d);
''' This is tricky '''
leftRotateRec(arr, n - d + i, 2 * d - n, d);
''' UTILITY FUNCTIONS '''
''' function to print an array '''
def printArray(arr, size):
for i in range(size):
print(arr[i], end = " ");
print();
'''
* This function swaps d elements starting at
* index fi with d elements starting at index si
'''
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;
# Driver Code
if __name__ == '__main__':
arr = [1, 2, 3, 4, 5, 6, 7];
leftRotate(arr, 2, 7);
printArray(arr, 7);
# This code is contributed by Rohit_ranjan
using System;
class GFG{
// Wrapper over the recursive function
// leftRotateRec()
// It left rotates []arr by d.
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)
{
// Return If number of elements
// to be rotated is zero or equal
// to array size
if(d == 0 || d == n)
return;
// If number of elements to be rotated
// is exactly half of array size
if(n - d == d)
{
swap(arr, i, n - d + i, d);
return;
}
// If A is shorter
if(d < n - d)
{
swap(arr, i, n - d + i, d);
leftRotateRec(arr, i, d, n - d);
}
// If B is shorter
else
{
swap(arr, i, d, n - d);
// This is tricky
leftRotateRec(arr, n - d + i,
2 * d - n, d);
}
}
// UTILITY FUNCTIONS
// Function to print an array
public static void printArray(int []arr,
int size)
{
int i;
for(i = 0; i < size; i++)
Console.Write(arr[i] + " ");
Console.WriteLine();
}
// This function swaps d elements
// starting at index fi with d elements
// starting at index si
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;
}
}
// Driver Code
public static void Main(String[] args)
{
int []arr = { 1, 2, 3, 4, 5, 6, 7 };
leftRotate(arr, 2, 7);
printArray(arr, 7);
}
}
// This code is contributed by amal kumar choubey
<script>
let leftRotate = (arr, d, n) =>{
/* Return If number of elements to be rotated
is zero or equal to array size */
if(d == 0 || d == n)
return;
/*If number of elements to be rotated
is exactly half of array size */
if(n - d == d) {
arr = swap(arr, 0, n - d, d);
return;
}
/* If A is shorter*/
if(d < n - d) {
arr = swap(arr, 0, n - d, d);
leftRotate(arr, d, n - d);
}
else{
/* If B is shorter*/
arr = swap(arr, 0, d, n - d);
/*This is tricky*/
leftRotate(arr + n - d, 2 * d - n, d);
}
}
/*UTILITY FUNCTIONS*/
/* function to print an array */
let printArray = (arr, size) =>{
ans = ''
for(let i = 0; i < size; i++)
ans += arr[i]+" ";
document.write(ans)
}
/*This function swaps d elements
starting at index fi
with d elements starting at index si */
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
}
// Driver Code
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++
// C++ code for above implementation
#include <bits/stdc++.h>
using namespace std;
/*UTILITY FUNCTIONS*/
/* function to print an array */
void printArray(int arr[], int size)
{
int i;
for (i = 0; i < size; i++)
cout << arr[i] << " ";
cout << endl;
}
/*This function swaps d elements starting at index fi
with d elements starting at index si */
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;
}
}
// This code is contributed by rathbhupendra
void leftRotate(int arr[], int d, int n)
{
int i, j;
if (d == 0 || d == n)
return;
/* If number of elements to be rotated is more than
* array size*/
if (d > n)
d = d % n;
i = d;
j = n - d;
while (i != j) {
if (i < j) /*A is shorter*/
{
swap(arr, d - i, d + j - i, i);
j -= i;
}
else /*B is shorter*/
{
swap(arr, d - i, d, j);
i -= j;
}
// printArray(arr, 7);
}
/*Finally, block swap A and B*/
swap(arr, d - i, d, i);
}
// Driver Code
int main()
{
int arr[] = { 1, 2, 3, 4, 5, 6, 7 };
leftRotate(arr, 2, 7);
printArray(arr, 7);
return 0;
}
// This code is contributed by Shivani
// C code for above implementation
#include <stdio.h>
/*UTILITY FUNCTIONS*/
/* function to print an array */
void printArray(int arr[], int size)
{
int i;
for (i = 0; i < size; i++)
printf("%d ", arr[i]);
printf("\n ");
}
/*This function swaps d elements starting at index fi
with d elements starting at index si */
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 number of elements to be rotated is more than
* array size*/
if (d > n)
d = d % n;
i = d;
j = n - d;
while (i != j) {
if (i < j) /*A is shorter*/
{
swap(arr, d - i, d + j - i, i);
j -= i;
}
else /*B is shorter*/
{
swap(arr, d - i, d, j);
i -= j;
}
// printArray(arr, 7);
}
/*Finally, block swap A and B*/
swap(arr, d - i, d, i);
}
/* Driver program to test above functions */
int main()
{
int arr[] = { 1, 2, 3, 4, 5, 6, 7 };
leftRotate(arr, 2, 7);
printArray(arr, 7);
getchar();
return 0;
}
// Java code for above implementation
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 number of elements to be rotated is more than
* array size*/
if (d > n)
d = d % n;
i = d;
j = n - d;
while (i != j) {
if (i < j) /*A is shorter*/
{
swap(arr, d - i, d + j - i, i);
j -= i;
}
else /*B is shorter*/
{
swap(arr, d - i, d, j);
i -= j;
}
// printArray(arr, 7);
}
/*Finally, block swap A and B*/
swap(arr, d - i, d, i);
}
/*UTILITY FUNCTIONS*/
/* function to print an array */
public static void printArray(int arr[], int size)
{
int i;
for (i = 0; i < size; i++)
System.out.print(arr[i] + " ");
System.out.println();
}
/*This function swaps d elements
starting at index fi with d elements
starting at index si */
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;
}
}
// Driver Code
public static void main(String[] args)
{
int arr[] = { 1, 2, 3, 4, 5, 6, 7 };
leftRotate(arr, 2, 7);
printArray(arr, 7);
}
}
# Python3 code for above implementation
# Wrapper over the recursive function leftRotateRec()
# It left rotates arr by d.
''' UTILITY FUNCTIONS '''
''' function to print an array '''
def printArray(arr, size):
for i in range(size):
print(arr[i], end=" ")
print()
'''
* This function swaps d elements starting at
* index fi with d elements starting at index si
'''
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): # A is shorter
swap(arr, d - i, d + j - i, i)
j -= i
else: # B is shorter
swap(arr, d - i, d, j)
i -= j
swap(arr, d - i, d, i)
# Driver Code
if __name__ == '__main__':
arr = [1, 2, 3, 4, 5, 6, 7]
leftRotate(arr, 2, 7)
printArray(arr, 7)
// C# code for above implementation
using System;
class GFG {
// UTILITY FUNCTIONS
// Function to print an array
public static void printArray(int[] arr, int size)
{
int i;
for (i = 0; i < size; i++)
Console.Write(arr[i] + " ");
Console.WriteLine();
}
// This function swaps d elements
// starting at index fi with d elements
// starting at index si
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 number of elements to be rotated is more than
* array size*/
if (d > n)
d = d % n;
i = d;
j = n - d;
while (i != j) {
if (i < j) /*A is shorter*/
{
swap(arr, d - i, d + j - i, i);
j -= i;
}
else /*B is shorter*/
{
swap(arr, d - i, d, j);
i -= j;
}
}
/*Finally, block swap A and B*/
swap(arr, d - i, d, i);
}
// Driver Code
public static void Main(String[] args)
{
int[] arr = { 1, 2, 3, 4, 5, 6, 7 };
leftRotate(arr, 2, 7);
printArray(arr, 7);
}
}
// This code is contributed by Rajput-Ji
<script>
// JavaScript code for above implementation
function leftRotate(arr, d, n)
{
if(d == 0 || d == n)
return;
let i = d;
let j = n - d;
while (i != j)
{
if(i < j)
{
// A is shorter
arr = swap(arr, d - i, d + j - i, i);
j -= i;
}
else{ // B is shorter
arr = swap(arr, d - i, d, j);
i -= j;
}
}
arr = swap(arr, d - i, d, i);
// This code is contributed by rohitsingh04052.
}
</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.
Similar Reads
Javascript Program for Block swap algorithm for array rotation Write a function rotate(ar[], d, n) that rotates arr[] of size n by d elements. Rotation of the above array by 2 will make 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 i
3 min read
Reversal algorithm for Array rotation Given an array arr[] of size N, the task is to rotate the array by d position to the left. Examples: Input: arr[] = {1, 2, 3, 4, 5, 6, 7}, d = 2Output: 3, 4, 5, 6, 7, 1, 2Explanation: If the array is rotated by 1 position to the left, it becomes {2, 3, 4, 5, 6, 7, 1}.When it is rotated further by 1
15 min read
Juggling Algorithm for Array Rotation Given an array arr[], the task is to rotate the array by d positions to the left using juggling algorithm. Examples: Input: arr[] = {1, 2, 3, 4, 5, 6}, d = 2Output: {3, 4, 5, 6, 1, 2}Explanation: After first left rotation, arr[] becomes {2, 3, 4, 5, 6, 1} and after the second rotation, arr[] becomes
9 min read
Reversal algorithm for right rotation of an array Given an array, right rotate it by k elements. After K=3 rotation Examples: Input: arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10} k = 3 Output: 8 9 10 1 2 3 4 5 6 7 Input: arr[] = {121, 232, 33, 43 ,5} k = 2 Output: 43 5 121 232 33 Note : In the below solution, k is assumed to be smaller than or equal to n
6 min read
Array after K Rotations Given an array arr[] and an integer k, rotate the array in place k times to the right (clockwise). In each rotation, the last element moves to the front, and all other elements shift one position to the right. Modify the array in place, do not return anything.Examples : Input: arr[] = [1, 2, 3, 4, 5
12 min read