Block swap algorithm for array rotation - GeeksforGeeks

10 Mar, 2022
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:
C++
C
Java
Python3
C#
Javascript
#include <bits/stdc++.h>using namespace std; /*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 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*/    }} /*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 fiwith 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 Codeint 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 elementsstarting at index fi with d elementsstarting 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 Codepublic 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 Codeif __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 arraypublic 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 sipublic 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 Codepublic 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 elementsstarting at index fiwith 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 Codearr = [1, 2, 3, 4, 5, 6, 7];leftRotate(arr, 2, 7);printArray(arr, 7); </script>
3 4 5 6 7 1 2 
Iterative Implementation: Here is iterative implementation of the same algorithm. Same utility function swap() is used here.
C++
C
Java
Python3
C#
Javascript
// C++ code for above implementationvoid 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);} // This code is contributed by Shivani
// C code for above implementationvoid 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);}
//Java code for above implementationstatic 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);}
# Python3 code for above implementation 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) # This code is contributed# by Adarsh_Verma
// C# code for above implementationstatic 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);} // This code is contributed by Rajput-Ji
<script>// JavaScript code for above implementationfunction 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 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.pdfPlease write comments if you find any bug in the above programs/algorithms or want to share any additional information about the block swap algorithm.
AbhijeetPal
prerna saini
Adarsh_Verma
Rajput-Ji
rathbhupendra
CodeSeeker
Amal Kumar Choubey
Rohit_ranjan
rohitsingh07052
shivanisinghss2110
yashguptaindianera5
mahmady173
surinderdawra388
rishavnitro
rotation
Arrays
Arrays
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Maximum and minimum of an array using minimum number of comparisons
Top 50 Array Coding Problems for Interviews
Largest Sum Contiguous Subarray
Multidimensional Arrays in Java
Linear Search
Python | Using 2D arrays/lists the right way
Find the Missing Number
Subset Sum Problem | DP-25
Array of Strings in C++ (5 Different Ways to Create)
Find Second largest element in an array