Skip to content
Related Articles

Related Articles

Save Article
Improve Article
Save Article
Like Article

Block swap algorithm for array rotation

  • Difficulty Level : Medium
  • Last Updated : 26 May, 2021

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

Array

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Rotation of the above array by 2 will make 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 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 pran 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 5 4 6 7 1 2

Iterative Implementation: 
Here is iterative implementation of the same algorithm. 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;
         
    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;
  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;
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;
    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)
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.




My Personal Notes arrow_drop_up
Recommended Articles
Page :