JavaScript Program for Block swap algorithm for array rotation

Rotation of the array elements means moving the elements of the given array to either the left or right side by some number of specific positions. We will assume the array in the cyclic form and rotate the elements of the edges to the other end. Block swap algorithm for array rotation means to rotate the elements of the array by a given number but not using the rotation but the swapping technique. We will implement both recursive as well as iterative approaches.

Input

The given array is [ 1, 2, 3, 4, 5, 6, 7].
The number of rotations by which we have to rotate is 3. 

Output

[4, 5, 6, 7, 1, 2, 3]

Explanation

We can use the swap algorithm and get the result and we will implement that in the next section.

Recursive Approach

In this approach, we will try to assume that we have two array and the first array is of the size number of rotations given and the other array have the size of total minus given number of elements.

If the size of the first array is small, then we will swap the elements of first array with the last elements equal to the size of the first array and if the size of the first array is greater than we will swap the first elements equals to the size of the second array with the given array.

For remaining elements, we will call the recursive function by changing the array of swapping.

Example

function swap(arr, st, si, k){    
   // function to traverse over the array and swap the elements 
   for(var i = 0; i < k; i++) {
      var temp = arr[st + i];
      arr[st + i] = arr[si + i];
      arr[si + i] = temp;
   }
   return arr;
}
function rotate(arr, k, n){

   // if the number of rotations is zero or equal to the size of array
   // in this case we don't have to rotate the array 
   if(k == 0 || k == n){
      return;
   }
   
   // special case when the number of elements to rotate 
   // is half of the size of the given array
   if(n == 2*k){
      arr = swap(arr, 0, n - k, k);
      return;
   }		
   
   // if the first part is short	
   if(2*k < n) {
      arr = swap(arr, 0, n - k, k);
      rotate(arr, k, n - k);	
   }
   else{	
   
      // if second part is short
      arr = swap(arr, 0, k, n - k);
      rotate(arr + n - k, 2 * k - n, k);
   }
}

// function to print the given array 
function print(arr){
   var temp = "";
   for(var i = 0; i < arr.length; i++){
      temp += arr[i] + " ";
   }
   console.log(temp);
}

//Defining the array 
var arr = [1, 2, 3, 4, 5, 6, 7];
var num = 3;
console.log("The given array is: ");
print(arr);

// rotating the array 
rotate(arr, num, arr.length);
console.log("The given array after " + num + " number of rotations is: ")
print(arr);

Time and Space Complexity

The time complexity of the above code is N, where N is the size of the given array.

The space complexity of the above code is N, but this is only if we consider the memory taken by the recursive stack.

Iterative Approach

The iterative approach is the same as the recursive approach, the only difference is, that we work in the while loop not using the recursive calls. Let us see the code.

Example

function swap(arr, st, si, k){    
   // function to traverse over the array and swap the elements 
   for(var i = 0; i < k; i++) {
      var temp = arr[st + i];
      arr[st + i] = arr[si + i];
      arr[si + i] = temp;
   }
   return arr;
}
function rotate(arr, k, n){

   // if the number of rotations is zero or equal to the size of array
   // in this case we don't have to rotate the array 
   if(k == 0 || k == n){
      return;
   }
   var i = k;
   var j = n - k;
   while (i != j){
      if(i < j){
      
         // if the first array is shorter 
         arr = swap(arr, k - i, k + j - i, i);
         j -= i;
      }
      else{ 
      
         // if the second array is shorter 
         arr = swap(arr, k - i, k, j);
         i -= j;
      }
   }
   arr = swap(arr, k - i, k, i);
}

// function to print the given array 
function print(arr){
   var temp = "";
   for(var i = 0; i < arr.length; i++){
      temp += arr[i] + " ";
   }
   console.log(temp);
}

// defining the array 
var arr = [1, 2, 3, 4, 5, 6, 7];
var num = 3;
console.log("The given array is: ");
print(arr);

// rotating the array 
rotate(arr, num, arr.length);
console.log("The given array after " + num + " number of rotations is: ")
print(arr);

Time and Space Complexity

The time complexity of the above code is N, where N is the size of the given array.

The space complexity of the above code is 1 or constant, as we are not using any extra space here.

Conclusion

In this tutorial, we have implemented a JavaScript program to rotate the array by the given number of rotations by using the block swap algorithm. We have implemented the block swap algorithm with an iterative approach of O(N) time and O(1) space complexity and at the same time and O(N) space with a recursive approach.