Open in App
Not now

# Block swap algorithm for array rotation

• Difficulty Level : Medium
• Last Updated : 09 Dec, 2022

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 ` `using` `namespace` `std;`   `#include ` `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`

## C

 `#include`   `/*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

## Java

 `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`

## Python3

 `# 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`

## C#

 `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`

## Javascript

 ``

Output

```3 4 5 6 7 1 2
```

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 ` `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

 `// C code for above implementation`   `#include `   `/*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

 `// 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

 `# 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#

 `// 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`

## Javascript

 ``

Output

```3 4 5 6 7 1 2
```

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/

References:
http://www.cs.bell-labs.com/cm/cs/pearls/s02b.pdf
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.

My Personal Notes arrow_drop_up
Related Articles