Open In App

Reversal algorithm for right rotation of an array

Improve
Improve
Like Article
Like
Save
Share
Report

Given an array, right rotate it by k elements. 

After K=3 rotation 

Examples: 

Input: arr[] = {1, 2, 3, 4, 5, 
                6, 7, 8, 9, 10}
          k = 3
Output: 8 9 10 1 2 3 4 5 6 7

Input: arr[] = {121, 232, 33, 43 ,5}
           k = 2
Output: 43 5 121 232 33

Note : In the below solution, k is assumed to be smaller than or equal to n. We can easily modify the solutions to handle larger k values by doing k = k % n

Algorithm: 

rotate(arr[], d, n)
  reverse(arr[], 0, n-1) ;
  reverse(arr[], 0, d-1);
  reverse(arr[], d, n-1);

Below is the implementation of above approach: 

C++




// C++ program for right rotation of
// an array (Reversal Algorithm)
#include <bits/stdc++.h>
 
/*Function to reverse arr[]
from index start to end*/
void reverseArray(int arr[], int start,
                            int end)
{
    while (start < end)
    {
        std::swap(arr[start], arr[end]);
        start++;
        end--;
    }
}
 
/* Function to right rotate arr[]
of size n by d */
void rightRotate(int arr[], int d, int n)
{
    // if in case d>n,this will give segmentation fault.
    d=d%n;
    reverseArray(arr, 0, n-1);
    reverseArray(arr, 0, d-1);
    reverseArray(arr, d, n-1);
}
 
/* function to print an array */
void printArray(int arr[], int size)
{
    for (int i = 0; i < size; i++)
        std::cout << arr[i] << " ";
}
 
// driver code
int main()
{
    int arr[] = {1, 2, 3, 4, 5,
                6, 7, 8, 9, 10};
     
    int n = sizeof(arr)/sizeof(arr[0]);
    int k = 3;
     
    rightRotate(arr, k, n);
    printArray(arr, n);
 
    return 0;
}


Java




// Java program for right rotation of
// an array (Reversal Algorithm)
import java.io.*;
 
class GFG
{
    // Function to reverse arr[]
    // from index start to end
    static void reverseArray(int arr[], int start,
                             int end)
    {
        while (start < end)
        {
           int temp = arr[start];
           arr[start] = arr[end];
           arr[end] = temp;
           start++;
           end--;
         }
    }
 
    // Function to right rotate
    // arr[] of size n by d
    static void rightRotate(int arr[], int d, int n)
    {
       reverseArray(arr, 0, n - 1);
       reverseArray(arr, 0, d - 1);
       reverseArray(arr, d, n - 1);
    }
 
    // Function to print an array
    static void printArray(int arr[], int size)
    {
       for (int i = 0; i < size; i++)
          System.out.print(arr[i] + " ");
    }
 
    public static void main (String[] args)
    {
        int arr[] = {1, 2, 3, 4, 5,
                     6, 7, 8, 9, 10};
     
    int n = arr.length;
    int k = 3;
     
    rightRotate(arr, k, n);
    printArray(arr, n);
         
    }
}
// This code is contributed by Gitanjali.


Python3




# Python3 program for right rotation of
# an array (Reversal Algorithm)
 
 
# Function to reverse arr
# from index start to end
def reverseArray( arr, start, end):
     
    while (start < end):
         
        arr[start], arr[end] = arr[end], arr[start]
        start = start + 1
        end = end - 1
     
 
# Function to right rotate arr
# of size n by d
def rightRotate( arr, d, n):
     
    reverseArray(arr, 0, n - 1);
    reverseArray(arr, 0, d - 1);
    reverseArray(arr, d, n - 1);
 
 
# function to print an array
def printArray( arr, size):
    for i in range(0, size):
        print (arr[i], end = ' ')
 
 
# Driver code
arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
n = len(arr)
k = 3
     
# Function call
rightRotate(arr, k, n)
printArray(arr, n)
 
 
# This article is contributed
# by saloni1297


C#




// C# program for right rotation of
// an array (Reversal Algorithm)
using System;
 
class GFG {
     
    // Function to reverse arr[]
    // from index start to end
    static void reverseArray(int []arr, int start,
                                        int end)
    {
        while (start < end)
        {
            int temp = arr[start];
            arr[start] = arr[end];
            arr[end] = temp;
            start++;
            end--;
        }
    }
 
    // Function to right rotate
    // arr[] of size n by d
    static void rightRotate(int []arr, int d, int n)
    {
        reverseArray(arr, 0, n - 1);
        reverseArray(arr, 0, d - 1);
        reverseArray(arr, d, n - 1);
    }
 
    // Function to print an array
    static void printArray(int []arr, int size)
    {
        for (int i = 0; i < size; i++)
            Console.Write(arr[i] + " ");
    }
 
    // Driver code
    public static void Main ()
    {
        int []arr = {1, 2, 3, 4, 5,
                    6, 7, 8, 9, 10};
     
        int n = arr.Length;
        int k = 3;
     
        rightRotate(arr, k, n);
        printArray(arr, n);
         
    }
}
 
// This code is contributed by vt_m.


PHP




<?php
// PHP program for right rotation of
// an array (Reversal Algorithm)
 
/*Function to reverse arr[]
from index start to end*/
function reverseArray(&$arr, $start, $end)
{
    while ($start < $end)
    {
        $temp = $arr[$start];
        $arr[$start] = $arr[$end];
        $arr[$end] = $temp;
        $start++;
        $end--;
    }
}
 
/* Function to right rotate arr[]
of size n by d */
function rightRotate(&$arr, $d, $n)
{
    reverseArray($arr, 0, $n - 1);
    reverseArray($arr, 0, $d - 1);
    reverseArray($arr, $d, $n - 1);
}
 
/* function to print an array */
function printArray(&$arr, $size)
{
    for ($i = 0; $i < $size; $i++)
        echo $arr[$i] . " ";
}
 
// Driver code
$arr = array(1, 2, 3, 4, 5,
             6, 7, 8, 9, 10);
 
$n = sizeof($arr);
$k = 3;
 
rightRotate($arr, $k, $n);
printArray($arr, $n);
 
// This code is contributed by ita_c
?>


Javascript




<script>
// JavaScript program for right rotation of
// an array (Reversal Algorithm)
 
/*Function to reverse arr[]
from index start to end*/
function reverseArray(arr, start, end){
    while (start < end){
        let temp = arr[start];
        arr[start] = arr[end];
        arr[end] = temp;
        start++;
        end--;
    }
    return arr;
}
 
/* Function to right rotate arr[]
of size n by d */
function rightRotate(arr, d, n){
    arr = reverseArray(arr, 0, n-1);
    arr = reverseArray(arr, 0, d-1);
    arr = reverseArray(arr, d, n-1);
    return arr;
}
 
/* function to print an array */
function printArray( arr, size){
    for (let i = 0; i < size; i++)
        document.write( arr[i] + " ");
}
 
// driver code
let arr = [1, 2, 3, 4, 5,
                6, 7, 8, 9, 10];
     
let n = arr.length;
let k = 3;
     
arr = rightRotate(arr, k, n);
printArray(arr, n);
 
</script>


Output

8 9 10 1 2 3 4 5 6 7 

Time Complexity: O(n), as we are using a while loop to traverse N times.
Auxiliary Space: O(1), as we are not using any extra space.

 



Last Updated : 01 Aug, 2022
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads