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 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:**

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

**Iterative Implementation:**

Here is iterative implementation of the same algorithm. Same utility function swap() is used here.

`void` `leftRotate(` `int` `arr[], ` `int` `d, ` `int` `n) ` `{ ` ` ` `int` `i, j; ` ` ` `if` `(d == 0 || 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; ` ` ` `} ` ` ` `// printArray(arr, 7); ` ` ` `} ` ` ` `/*Finally, block swap A and B*/` ` ` `swap(arr, d-i, d, i); ` `} ` |

**Time Complexity:** O(n)

Please see 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.

## Recommended Posts:

- Quickly find multiple left rotations of an array | Set 1
- Maximum sum of i*arr[i] among all rotations of a given array
- Find maximum value of Sum( i*arr[i]) with only rotations on given array allowed
- Program to cyclically rotate an array by one
- Rearrange positive and negative numbers in O(n) time and O(1) extra space
- Check for Majority Element in a sorted array
- Sort elements by frequency | Set 1
- Leaders in an array
- Maximum sum such that no two elements are adjacent
- Reversal algorithm for array rotation
- Program for array rotation
- Write a program to reverse an array or string
- Merge an array of size n into another array of size m+n
- Search an element in a sorted and rotated array
- Majority Element