Block swap algorithm for array rotation in C++

The block swap algorithm for array rotation is an efficient algorithm that is used for array rotation. It can do your work in O(n) time complexity.
So, in array rotation, we are given an array arr[] of size n and a number k that define the no. of the element to be rotated.
Let’s see an example on array rotations −
Input  −
arr[] = {4, 6, 1, 8, 9, 2}, k = 2 (number of rotations.)
Output −
{1, 8, 9, 2, 4, 6}
Explanation − On rotation, we will shift the one element to the last position and shift the next elements to one position.
Element at index 0 will be shifted to index n-1. And the rest of the elements are shifted to the previous index.
The block swap algorithm is used to perform array rotations perfectly.
Step 1 − Divide the array two sub-arrays with k as division point. Let them be X = arr[0...k-1] and Y = arr[k...n-1].
Step 2 − Follow the below steps until the size of X and Y are the same.
Step 2.1 − If the size of X > Y, divide X into two portions X1 and X2 such that size of X1 is equal to the size of Y. Then swap the sub-array X1 and Y. This will change the original array formation from X1X2Y to YX2X1.
Step 2.2 − If the size of Y > X, divide Y into two portions Y1 and Y2 such that the size of Y2 is equal to the size of X. Then swap the subarray X and Y2. This will change the original array formation from XY1Y2 to Y2Y1X.
Step 3 − When the size of X and Y are the same, swap them.
This algorithm needs a repetitive call to the same chunk of code. This repetitive call can be achieved using two approaches. They are the recursive approach and iterative approach. we will discuss the approach using programs.
Program to illustrate Recursive Approach −
#include <iostream>
using namespace std;
void swapSubArray(int arr[], int start, int end, intk){
   int temp;
   for(int i = 0; i < k; i++){
      temp = arr[start + i];
      arr[start + i] = arr[end + i];
      arr[end + i] = temp;
   }
}
void blockSwapAlgo(int arr[], int k, int n) {
   if(k == 0 || k == n)
      return;
   if(k<(n-k)) {
      swapSubArray(arr, 0, (n-k), k);
      blockSwapAlgo(arr, k, (n-k));
   }
   else if(k>(n-k)){
      swapSubArray(arr, 0, k, (n-k));
      blockSwapAlgo((arr+n-k), (2*k-n), k);
   }
   else{
      swapSubArray(arr, 0, (n-k), k);
      return;
   }
}
int main() {
   int arr[] = {4, 6, 1, 8, 9, 2};
   int size = sizeof(arr) / sizeof(arr[0]);
   int k = 3;
   cout<<"Array before rotations :\t";
   for(int i = 0; i<size; i++)
      cout<<arr[i]<<" ";
   blockSwapAlgo(arr, k, size);
   cout<<"\nArray after rotating "<<k<<" times :\t";
   for(int i = 0; i<size; i++)
      cout<<arr[i]<<" ";
   return 0;
}
Array before rotations : 4 6 1 8 9 2
Array after rotating 3 times : 8 9 2 4 6 1
Program to illustrate iterative Approach −
 Live Demo
#include <iostream>
using namespace std;
void swapSubArray(int arr[], int start, int end, int k){
   int temp;
   for(int i = 0; i < k; i++){
      temp = arr[start + i];
      arr[start + i] = arr[end + i];
      arr[end + i] = temp;
   }
}
void blockSwapAlgoIt(int arr[], int k, int size) {
   int i, j;
   if(k == 0 || k == size)
      return;
   i = k;
   j = size - k;
   while (i != j) {
      if(i < j){
         swapSubArray(arr, k-i, k+j-i, i);
         j -= i;
      }
      else{
         swapSubArray(arr, k-i, k, j);
         i -= j;
      }
   }
   swapSubArray(arr, k-i, k, i);
}
int main() {
   int arr[] = {4, 6, 1, 8, 9, 2};
   int size = sizeof(arr) / sizeof(arr[0]);
   int k = 3;
   cout<<"Array before rotations :\t";
   for(int i = 0; i<size; i++)
      cout<<arr[i]<<" ";
   blockSwapAlgoIt(arr, k, size);
   cout<<"\nArray after rotating "<<k<<" times :\t";
   for(int i = 0; i<size; i++)
      cout<<arr[i]<<" ";
   return 0;
}
Array before rotations : 4 6 1 8 9 2
Array after rotating 3 times : 8 9 2 4 6 1