The Wayback Machine - https://web.archive.org/web/20211009013449/https://www.geeksforgeeks.org/array-rotation/
Skip to content
Related Articles

Related Articles

Improve Article

Program for array rotation

  • Difficulty Level : Easy
  • Last Updated : 23 Jul, 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

 

METHOD 1 (Using temp array) 

Input arr[] = [1, 2, 3, 4, 5, 6, 7], d = 2, n =7
1) Store the first d elements in a temp array
   temp[] = [1, 2]
2) Shift rest of the arr[]
   arr[] = [3, 4, 5, 6, 7, 6, 7]
3) Store back the d elements
   arr[] = [3, 4, 5, 6, 7, 1, 2]

Time complexity : O(n) 
Auxiliary Space : O(d)

METHOD 2 (Rotate one by one)  

leftRotate(arr[], d, n)
start
  For i = 0 to i < d
    Left rotate all elements of arr[] by one
end

To rotate by one, store arr[0] in a temporary variable temp, move arr[1] to arr[0], arr[2] to arr[1] â€Ķand finally temp to arr[n-1]
Let us take the same example arr[] = [1, 2, 3, 4, 5, 6, 7], d = 2 
Rotate arr[] by one 2 times 
We get [2, 3, 4, 5, 6, 7, 1] after first rotation and [ 3, 4, 5, 6, 7, 1, 2] after second rotation.
Below is the implementation of the above approach : 
 

C++




// C++ program to rotate an array by
// d elements
#include <bits/stdc++.h>
using namespace std;
 
/*Function to left Rotate arr[] of
  size n by 1*/
void leftRotatebyOne(int arr[], int n)
{
    int temp = arr[0], i;
    for (i = 0; i < n - 1; i++)
        arr[i] = arr[i + 1];
 
    arr[n-1] = temp;
}
 
/*Function to left rotate arr[] of size n by d*/
void leftRotate(int arr[], int d, int n)
{
    for (int i = 0; i < d; i++)
        leftRotatebyOne(arr, n);
}
 
/* utility function to print an array */
void printArray(int arr[], int n)
{
    for (int i = 0; i < n; i++)
        cout << arr[i] << " ";
}
 
/* Driver program to test above functions */
int main()
{
    int arr[] = { 1, 2, 3, 4, 5, 6, 7 };
    int n = sizeof(arr) / sizeof(arr[0]);
 
    // Function calling
    leftRotate(arr, 2, n);
    printArray(arr, n);
 
    return 0;
}
C



// C program to rotate an array by
// d elements
#include <stdio.h>
 
/* Function to left Rotate arr[] of size n by 1*/
void leftRotatebyOne(int arr[], int n);
 
/*Function to left rotate arr[] of size n by d*/
void leftRotate(int arr[], int d, int n)
{
    int i;
    for (i = 0; i < d; i++)
        leftRotatebyOne(arr, n);
}
 
void leftRotatebyOne(int arr[], int n)
{
    int temp = arr[0], i;
    for (i = 0; i < n - 1; i++)
        arr[i] = arr[i + 1];
    arr[n-1] = temp;
}
 
/* utility function to print an array */
void printArray(int arr[], int n)
{
    int i;
    for (i = 0; i < n; i++)
        printf("%d ", arr[i]);
}
 
/* Driver program to test above functions */
int main()
{
    int arr[] = { 1, 2, 3, 4, 5, 6, 7 };
    leftRotate(arr, 2, 7);
    printArray(arr, 7);
    return 0;
}
Java



// Java program to rotate an array by
// d elements
 
class RotateArray {
    /*Function to left rotate arr[] of size n by d*/
    void leftRotate(int arr[], int d, int n)
    {
        for (int i = 0; i < d; i++)
            leftRotatebyOne(arr, n);
    }
 
    void leftRotatebyOne(int arr[], int n)
    {
        int i, temp;
        temp = arr[0];
        for (i = 0; i < n - 1; i++)
            arr[i] = arr[i + 1];
        arr[n-1] = temp;
    }
 
    /* utility function to print an array */
    void printArray(int arr[], int n)
    {
        for (int i = 0; i < n; i++)
            System.out.print(arr[i] + " ");
    }
 
    // Driver program to test above functions
    public static void main(String[] args)
    {
        RotateArray rotate = new RotateArray();
        int arr[] = { 1, 2, 3, 4, 5, 6, 7 };
        rotate.leftRotate(arr, 2, 7);
        rotate.printArray(arr, 7);
    }
}
 
// This code has been contributed by Mayank Jaiswal
Python3



# Python3 program to rotate an array by
# d elements
# Function to left rotate arr[] of size n by d*/
def leftRotate(arr, d, n):
    for i in range(d):
        leftRotatebyOne(arr, n)
 
# Function to left Rotate arr[] of size n by 1*/
def leftRotatebyOne(arr, n):
    temp = arr[0]
    for i in range(n-1):
        arr[i] = arr[i + 1]
    arr[n-1] = temp
         
 
# utility function to print an array */
def printArray(arr, size):
    for i in range(size):
        print ("% d"% arr[i], end =" ")
 
  
# Driver program to test above functions */
arr = [1, 2, 3, 4, 5, 6, 7]
leftRotate(arr, 2, 7)
printArray(arr, 7)
 
# This code is contributed by Shreyanshi Arun
C#



// C# program for array rotation
using System;
 
class GFG {
    /* Function to left rotate arr[]
    of size n by d*/
    static void leftRotate(int[] arr, int d,
                           int n)
    {
        for (int i = 0; i < d; i++)
            leftRotatebyOne(arr, n);
    }
 
    static void leftRotatebyOne(int[] arr, int n)
    {
        int i, temp = arr[0];
        for (i = 0; i < n - 1; i++)
            arr[i] = arr[i + 1];
 
        arr[n-1] = temp;
    }
 
    /* utility 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 };
        leftRotate(arr, 2, 7);
        printArray(arr, 7);
    }
}
 
// This code is contributed by Sam007
PHP



<?php
// PHP program to rotate an array
// by d elements
 
/*Function to left Rotate arr[] 
of size n by 1*/
function leftRotatebyOne(&$arr, $n)
{
    $temp = $arr[0];
    for ($i = 0; $i < $n - 1; $i++)
        $arr[$i] = $arr[$i + 1];
 
    $arr[$n-1] = $temp;
}
 
/*Function to left rotate arr[]
  of size n by d*/
function leftRotate(&$arr, $d, $n)
{
    for ($i = 0; $i < $d; $i++)
        leftRotatebyOne($arr, $n);
}
 
/* utility function to print
   an array */
function printArray(&$arr, $n)
{
    for ($i = 0; $i < $n; $i++)
        echo $arr[$i] . " ";
}
 
// Driver Code
$arr = array( 1, 2, 3, 4, 5, 6, 7 );
$n = sizeof($arr);
 
// Function calling
leftRotate($arr, 2, $n);
printArray($arr, $n);
 
// This code is contributed
// by ChitraNayal
?>
Javascript



<script>
 
// JavaScript program to rotate an array by
// d elements
 
 
    /* Function to left rotate arr of size n by d */
    function leftRotate(arr , d , n) {
        for (i = 0; i < d; i++)
            leftRotatebyOne(arr, n);
    }
 
    function leftRotatebyOne(arr , n) {
        var i, temp;
        temp = arr[0];
        for (i = 0; i < n - 1; i++)
            arr[i] = arr[i + 1];
        arr[n - 1] = temp;
    }
 
    /* utility function to print an array */
    function printArray(arr , n) {
        for (i = 0; i < n; i++)
            document.write(arr[i] + " ");
    }
 
    // Driver program to test above functions
     
        var arr = [ 1, 2, 3, 4, 5, 6, 7 ];
        leftRotate(arr, 2, 7);
        printArray(arr, 7);
 
// This code is contributed by todaysgaurav
 
</script>
Output :  
3 4 5 6 7 1 2 
Time complexity : O(n * d) 
Auxiliary Space : O(1)
METHOD 3 (A Juggling Algorithm) 
This is an extension of method 2. Instead of moving one by one, divide the array in different sets 
where number of sets is equal to GCD of n and d and move the elements within sets. 
If GCD is 1 as is for the above example array (n = 7 and d =2), then elements will be moved within one set only, we just start with temp = arr[0] and keep moving arr[I+d] to arr[I] and finally store temp at the right place.
Here is an example for n =12 and d = 3. GCD is 3 and 
 
Let arr[] be {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}

a) Elements are first moved in first set – (See below 
   diagram for this movement)
          arr[] after this step --> {4 2 3 7 5 6 10 8 9 1 11 12}

b)    Then in second set.
          arr[] after this step --> {4 5 3 7 8 6 10 11 9 1 2 12}

c)    Finally in third set.
          arr[] after this step --> {4 5 6 7 8 9 10 11 12 1 2 3}
Below is the implementation of the above approach :
 
C++



// C++ program to rotate an array by
// d elements
#include <bits/stdc++.h>
using namespace std;
 
/*Function to get gcd of a and b*/
int gcd(int a, int b)
{
    if (b == 0)
        return a;
 
    else
        return gcd(b, a % b);
}
 
/*Function to left rotate arr[] of siz n by d*/
void leftRotate(int arr[], int d, int n)
{
    /* To handle if d >= n */
    d = d % n;
    int g_c_d = gcd(d, n);
    for (int i = 0; i < g_c_d; i++) {
        /* move i-th values of blocks */
        int temp = arr[i];
        int j = i;
 
        while (1) {
            int k = j + d;
            if (k >= n)
                k = k - n;
 
            if (k == i)
                break;
 
            arr[j] = arr[k];
            j = k;
        }
        arr[j] = temp;
    }
}
 
// Function to print an array
void printArray(int arr[], int size)
{
    for (int i = 0; i < size; i++)
        cout << arr[i] << " ";
}
 
/* Driver program to test above functions */
int main()
{
    int arr[] = { 1, 2, 3, 4, 5, 6, 7 };
    int n = sizeof(arr) / sizeof(arr[0]);
 
    // Function calling
    leftRotate(arr, 2, n);
    printArray(arr, n);
 
    return 0;
}
C



// C program to rotate an array by
// d elements
#include <stdio.h>
 
/* function to print an array */
void printArray(int arr[], int size);
 
/*Fuction to get gcd of a and b*/
int gcd(int a, int b);
 
/*Function to left rotate arr[] of siz n by d*/
void leftRotate(int arr[], int d, int n)
{
    int i, j, k, temp;
    /* To handle if d >= n */
    d = d % n;
    int g_c_d = gcd(d, n);
    for (i = 0; i < g_c_d; i++) {
        /* move i-th values of blocks */
        temp = arr[i];
        j = i;
        while (1) {
            k = j + d;
            if (k >= n)
                k = k - n;
            if (k == i)
                break;
            arr[j] = arr[k];
            j = k;
        }
        arr[j] = temp;
    }
}
 
/*UTILITY FUNCTIONS*/
/* function to print an array */
void printArray(int arr[], int n)
{
    int i;
    for (i = 0; i < n; i++)
        printf("%d ", arr[i]);
}
 
/*Fuction to get gcd of a and b*/
int gcd(int a, int b)
{
    if (b == 0)
        return a;
    else
        return gcd(b, a % b);
}
 
/* 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



// Java program to rotate an array by
// d elements
class RotateArray {
    /*Function to left rotate arr[] of siz n by d*/
    void leftRotate(int arr[], int d, int n)
    {
        /* To handle if d >= n */
        d = d % n;
        int i, j, k, temp;
        int g_c_d = gcd(d, n);
        for (i = 0; i < g_c_d; i++) {
            /* move i-th values of blocks */
            temp = arr[i];
            j = i;
            while (true) {
                k = j + d;
                if (k >= n)
                    k = k - n;
                if (k == i)
                    break;
                arr[j] = arr[k];
                j = k;
            }
            arr[j] = temp;
        }
    }
 
    /*UTILITY FUNCTIONS*/
 
    /* function to print an array */
    void printArray(int arr[], int size)
    {
        int i;
        for (i = 0; i < size; i++)
            System.out.print(arr[i] + " ");
    }
 
    /*Fuction to get gcd of a and b*/
    int gcd(int a, int b)
    {
        if (b == 0)
            return a;
        else
            return gcd(b, a % b);
    }
 
    // Driver program to test above functions
    public static void main(String[] args)
    {
        RotateArray rotate = new RotateArray();
        int arr[] = { 1, 2, 3, 4, 5, 6, 7 };
        rotate.leftRotate(arr, 2, 7);
        rotate.printArray(arr, 7);
    }
}
 
// This code has been contributed by Mayank Jaiswal
Python3



# Python3 program to rotate an array by
# d elements
# Function to left rotate arr[] of size n by d
def leftRotate(arr, d, n):
    d = d % n
    g_c_d = gcd(d, n)
    for i in range(g_c_d):
         
        # move i-th values of blocks
        temp = arr[i]
        j = i
        while 1:
            k = j + d
            if k >= n:
                k = k - n
            if k == i:
                break
            arr[j] = arr[k]
            j = k
        arr[j] = temp
 
# UTILITY FUNCTIONS
# function to print an array
def printArray(arr, size):
    for i in range(size):
        print ("% d" % arr[i], end =" ")
 
# Fuction to get gcd of a and b
def gcd(a, b):
    if b == 0:
        return a;
    else:
        return gcd(b, a % b)
 
# Driver program to test above functions
arr = [1, 2, 3, 4, 5, 6, 7]
n = len(arr)
d = 2
leftRotate(arr, d, n)
printArray(arr, n)
 
# This code is contributed by Shreyanshi Arun
C#



// C# program for array rotation
using System;
 
class GFG {
    /* Function to left rotate arr[]
    of size n by d*/
    static void leftRotate(int[] arr, int d,
                           int n)
    {
        int i, j, k, temp;
        /* To handle if d >= n */
        d = d % n;
        int g_c_d = gcd(d, n);
        for (i = 0; i < g_c_d; i++) {
            /* move i-th values of blocks */
            temp = arr[i];
            j = i;
            while (true) {
                k = j + d;
                if (k >= n)
                    k = k - n;
                if (k == i)
                    break;
                arr[j] = arr[k];
                j = k;
            }
            arr[j] = temp;
        }
    }
 
    /*UTILITY FUNCTIONS*/
    /* Function to print an array */
    static void printArray(int[] arr, int size)
    {
        for (int i = 0; i < size; i++)
            Console.Write(arr[i] + " ");
    }
 
    /* Fuction to get gcd of a and b*/
    static int gcd(int a, int b)
    {
        if (b == 0)
            return a;
        else
            return gcd(b, a % b);
    }
 
    // Driver code
    public static void Main()
    {
        int[] arr = { 1, 2, 3, 4, 5, 6, 7 };
        leftRotate(arr, 2, 7);
        printArray(arr, 7);
    }
}
 
// This code is contributed by Sam007
Javascript



<script>
 
// JavaScript program to rotate an array by
// d elements
 
/*Fuction to get gcd of a and b*/
function gcd( a, b){
    if (b == 0)
        return a;
    else
        return gcd(b, a % b);
}
 
/*Function to left rotate arr[] of siz n by d*/
function leftRotate(arr, d, n){
    /* To handle if d >= n */
    d = d % n;
    let g_c_d = gcd(d, n);
    for (let i = 0; i < g_c_d; i++) {
        /* move i-th values of blocks */
        let temp = arr[i];
        let j = i;
 
        while (1) {
            let k = j + d;
            if (k >= n)
                k = k - n;
 
            if (k == i)
                break;
 
            arr[j] = arr[k];
            j = k;
        }
        arr[j] = temp;
    }
}
 
// Function to print an array
function printArray(arr, size){
    for (let i = 0; i < size; i++)
        document.write(arr[i] +" ");
}
 
/* Driver program to test above functions */
let arr = [ 1, 2, 3, 4, 5, 6, 7 ];
let n = arr.length;
// Function calling
leftRotate(arr, 2, n);
printArray(arr, n);
 
</script>
Output : 
3 4 5 6 7 1 2 
Time complexity : O(n) 
Auxiliary Space : O(1)
 
 
Please see following posts for other methods of array rotation: 
Block swap algorithm for array rotation 
Reversal algorithm for array rotation
Please write comments if you find any bug in above programs/algorithms.
 


My Personal Notes
arrow_drop_up
Next

Reversal algorithm for array rotation
Recommended Articles
Page :
Left Rotation and Right Rotation of a String
15, May 17
C Program for Reversal algorithm for array rotation
10, Nov 09
Java Program for Reversal algorithm for array rotation
10, Nov 09
Modify given array to a non-decreasing array by rotation
22, Feb 21
Reversal algorithm for array rotation
10, Nov 09
Block swap algorithm for array rotation
14, Nov 09
Print left rotation of array in O(n) time and O(1) space
30, Jul 17
Maximum number by concatenating every element in a rotation of an array
04, Jul 18
Left rotation of an array using vectors in C++
05, Sep 19
Circular rotation of an array using deque in C++
23, Sep 19
Find the Rotation Count in Rotated Sorted array
01, Mar 17
Rearrange array elements into alternate even-odd sequence by anticlockwise rotation of digits
28, Jan 21
Count of elements in array A left after performing deletion/rotation operation based on given conditions
22, Jul 21
Reversal algorithm for right rotation of an array
19, Jan 18
Sorting possible using size 3 subarray rotation
08, Mar 17
Lexicographically minimum string rotation | Set 1
14, Aug 14
Find a rotation with maximum hamming distance
15, Dec 17
Queries for rotation and Kth character of the given string in constant time
02, Sep 19
Maximize count of corresponding same elements in given Arrays by Rotation
16, Jun 20
Minimize characters to be changed to make the left and right rotation of a string same
14, Sep 20
Minimum number of flips with rotation to make binary string alternating
24, Aug 20
Longest subsequence of a number having same left and right rotation
25, Aug 20
Maximum number of 0s placed consecutively at the start and end in any rotation of a Binary String
12, Mar 21
Check if any pair of consecutive 1s can be separated by at most M 0s by circular rotation of a Binary String
25, Mar 21
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
GeeksforGeeks
Vote for difficulty
Current difficulty :
Easy





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox