Open In App

Javascript Program for Block swap algorithm for array rotation

Last Updated : 19 Sep, 2023
Summarize
Comments
Improve
Suggest changes
Share
Like Article
Like
Report

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

Array


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:

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

Time Complexity: O(N), where N represents the size of the given array.
Auxiliary Space: O(N), due to recursive stack space.

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

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), where N represents the size of the given array.
Auxiliary Space: O(1), no extra space is required, so it is a constant.


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/


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.

Please refer complete article on Block swap algorithm for array rotation for more details!


Article Tags :
Practice Tags :

Similar Reads