Skip to content
Related Articles

Related Articles

Block swap algorithm for array rotation

Improve Article
Save Article
  • Difficulty Level : Medium
  • Last Updated : 08 Nov, 2022
Improve Article
Save Article

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

Array

Rotation of the above array by 2 will make an array

ArrayRotation1

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;
 
/*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 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 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<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;
}   


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




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


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
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);
}
 
// This code is contributed by Shivani


C




// C code for above implementation
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);
}


Java




//Java code for above implementation
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);
}


Python3




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




// C# code for above implementation
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);
}
 
// This code is contributed by Rajput-Ji


Javascript




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

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

Start Your Coding Journey Now!