Program to cyclically rotate an array by one

Given an array, cyclically rotate the array clockwise by one. 

Examples:

Input:  arr[] = {1, 2, 3, 4, 5}
Output: arr[] = {5, 1, 2, 3, 4}

Following are steps. 
1) Store last element in a variable say x. 
2) Shift all elements one position ahead. 
3) Replace first element of array with x.

C++

// C++ code for program
// to cyclically rotate
// an array by one
# include <iostream>
using namespace std;

void rotate(int arr[], int n)
{
    int x = arr[n - 1], i;
    for (i = n - 1; i > 0; i--){
        arr[i] = arr[i - 1];
    }
    arr[0] = x;
}

// Driver code
int main()
{
    int arr[] = {1, 2, 3, 4, 5}, i;
    int n = sizeof(arr) /
            sizeof(arr[0]);

    cout << "Given array is \n";
    for (i = 0; i < n; i++)
        cout << arr[i] << ' ';

    rotate(arr, n);

    cout << "\nRotated array is\n";
    for (i = 0; i < n; i++)
        cout << arr[i] << ' ';

    return 0;
}

// This code is contributed by jit_t

C

#include <stdio.h>

void rotate(int arr[], int n)
{
   int x = arr[n-1], i;
   for (i = n-1; i > 0; i--)
      arr[i] = arr[i-1];
   arr[0] = x;
}

int main()
{
    int arr[] = {1, 2, 3, 4, 5}, i;
    int n = sizeof(arr)/sizeof(arr[0]);

    printf("Given array is\n");
    for (i = 0; i < n; i++)
        printf("%d ", arr[i]);

    rotate(arr, n);

    printf("\nRotated array is\n");
    for (i = 0; i < n; i++)
        printf("%d ", arr[i]);

    return 0;
}

Java

import java.util.Arrays;

public class Test
{
    static int arr[] = new int[]{1, 2, 3, 4, 5};

    // Method for rotation
    static void rotate()
    {
       int x = arr[arr.length-1], i;
       for (i = arr.length-1; i > 0; i--)
          arr[i] = arr[i-1];
       arr[0] = x;
    }

    /* Driver program */
    public static void main(String[] args)
    {
        System.out.println("Given Array is");
        System.out.println(Arrays.toString(arr));

        rotate();

        System.out.println("Rotated Array is");
        System.out.println(Arrays.toString(arr));
    }
}

Python3

# Python3 code for program to
# cyclically rotate an array by one

# Method for rotation
def rotate(arr, n):
    x = arr[n - 1]

    for i in range(n - 1, 0, -1):
        arr[i] = arr[i - 1];

    arr[0] = x;


# Driver function
arr= [1, 2, 3, 4, 5]
n = len(arr)
print ("Given array is")
for i in range(0, n):
    print (arr[i], end = ' ')

rotate(arr, n)

print ("\nRotated array is")
for i in range(0, n):
    print (arr[i], end = ' ')

# This article is contributed
# by saloni1297

C#

// C# code for program to cyclically
// rotate an array by one
using System;

public class Test
{
    static int []arr = new int[]{1, 2, 3, 4, 5};

    // Method for rotation
    static void rotate()
    {
    int x = arr[arr.Length - 1], i;

    for (i = arr.Length - 1; i > 0; i--)
        arr[i] = arr[i-1];
    arr[0] = x;
    }

    // Driver Code
    public static void Main()
    {
        Console.WriteLine("Given Array is");
        string Original_array = string.Join(" ", arr);
        Console.WriteLine(Original_array);

        rotate();

        Console.WriteLine("Rotated Array is");
        string Rotated_array = string.Join(" ", arr);
        Console.WriteLine(Rotated_array);
    }
}

// This code is contributed by vt_m.

PHP

<?php
// PHP code for program
// to cyclically rotate
// an array by one

function rotate(&$arr, $n)
{
    $x = $arr[$n - 1];
    for ($i = $n - 1;
         $i > 0; $i--)
    $arr[$i] = $arr[$i - 1];
    $arr[0] = $x;
}

// Driver code
$arr = array(1, 2, 3, 4, 5);
$n = sizeof($arr);

echo "Given array is \n";
for ($i = 0; $i < $n; $i++)
    echo $arr[$i] . " ";

rotate($arr, $n);

echo "\nRotated array is\n";
for ($i = 0; $i < $n; $i++)
    echo $arr[$i] . " ";

// This code is contributed
// by ChitraNayal
?>

Javascript

<script>

// JavaScript code for program
// to cyclically rotate
// an array by one
function rotate(arr, n)
{
  var x = arr[n-1], i;
  for(i = n-1; i > 0; i--)
      arr[i] = arr[i-1];
  arr[0] = x;
}

var arr = [1, 2, 3, 4, 5];
var n = arr.length;

document.write("Given array is <br>");
for(var i = 0; i< n; i++)
    document.write(arr[i] + " ");

rotate(arr, n);

document.write("<br>Rotated array is <br>");
for(var i = 0; i < n; i++)
    document.write(arr[i] + " ");

</script>

Output

Given array is 
1 2 3 4 5 
Rotated array is
5 1 2 3 4 

Time Complexity: O(n), as we need to iterate through all the elements. Where n is the number of elements in the array.
Auxiliary Space: O(1), as we are using constant space.

Another approach:

We can use two pointers, say i and j which point to first and last element of array respectively. As we know in cyclic rotation we will bring last element to first and shift rest in forward direction, so start swapping arr[i] and arr[j] and keep j fixed and i moving towards j.  Repeat till i is not equal to j.

C

#include <stdio.h>

void swap(int *x, int *y)
{
  int temp = *x;
  *x = *y;
  *y = temp;
}
void rotate(int arr[], int n)
{
  int i = 0, j = n - 1;
  while(i != j)
  {
    swap(&arr[i], &arr[j]);
    i++;
  }
}

int main()
{
    int arr[] = {1, 2, 3, 4, 5}, i;
    int n = sizeof(arr)/sizeof(arr[0]);

    printf("Given array is\n");
    for (i = 0; i < n; i++)
        printf("%d ", arr[i]);

    rotate(arr, n);

    printf("\nRotated array is\n");
    for (i = 0; i < n; i++)
        printf("%d ", arr[i]);

    return 0;
}

C++

#include <iostream>
using namespace std;

void rotate(int arr[], int n)
{
    int i = 0, j = n-1; // i and j pointing to first and last element respectively
      while(i != j){
      swap(arr[i], arr[j]);
      i++;
    }
}

// Driver code
int main()
{
    int arr[] = {1, 2, 3, 4, 5}, i;
    int n = sizeof(arr) /
            sizeof(arr[0]);

    cout << "Given array is \n";
    for (i = 0; i < n; i++)
        cout << arr[i] << " ";

    rotate(arr, n);

    cout << "\nRotated array is\n";
    for (i = 0; i < n; i++)
        cout << arr[i] << " ";

    return 0;
}

Java

import java.util.Arrays;

public class Test
{
    static int arr[] = new int[]{1, 2, 3, 4, 5};


    static void rotate()
    {
       int i = 0, j = arr.length - 1;
       while(i != j)
       {
         int temp = arr[i];
         arr[i] = arr[j];
         arr[j] = temp;
         i++;
       }
    }

    /* Driver program */
    public static void main(String[] args)
    {
        System.out.println("Given Array is");
        System.out.println(Arrays.toString(arr));

        rotate();

        System.out.println("Rotated Array is");
        System.out.println(Arrays.toString(arr));
    }
}

Python3

def rotate(arr, n):
    i = 0
    j = n - 1
    while i != j:
      arr[i], arr[j] = arr[j], arr[i]
      i = i + 1
    pass


# Driver function
arr= [1, 2, 3, 4, 5]
n = len(arr)
print ("Given array is")
for i in range(0, n):
    print (arr[i], end = ' ')

rotate(arr, n)

print ("\nRotated array is")
for i in range(0, n):
    print (arr[i], end = ' ')

C#

// C# code for program to cyclically
// rotate an array by one
using System;

class GFG{

static int []arr = new int[]{ 1, 2, 3, 4, 5 };

// Method for rotation
static void rotate()
{
    int n = arr[arr.Length - 1];

    // i and j pointing to first and
    // last element respectively
    int i = 0, j = n - 1;
    while(i != j)
    {
        {
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
    i++;
    }
}

// Driver Code
public static void Main()
{
    Console.WriteLine("Given Array is");
    string Original_array = string.Join(" ", arr);
    Console.WriteLine(Original_array);

    rotate();

    Console.WriteLine("Rotated Array is");
    string Rotated_array = string.Join(" ", arr);
    Console.WriteLine(Rotated_array);
}
}

// This code is contributed by annianni

Javascript

<script>
// JavaScript code for program
// to cyclically rotate
// an array by one using pointers i,j

function rotate(arr, n){
    var i = 0
    var j = n-1
    while(i != j){
        let temp;

        temp = arr[i];
        arr[i] = arr[j];
        arr[j]= temp;
        i =i+1
    }
}

var arr = [1, 2, 3, 4, 5];
var n = arr.length;

document.write("Given array is <br>");
for(var i = 0; i< n; i++)
    document.write(arr[i] + " ");

rotate(arr, n);

document.write("<br>Rotated array is <br>");
for(var i = 0; i < n; i++)
    document.write(arr[i] + " ");
</script>

Output

Given array is 
1 2 3 4 5 
Rotated array is
5 1 2 3 4 

Time Complexity: O(n), as we need to iterate through all the elements. Where n is the number of elements in the array.
Auxiliary Space: O(1), as we are using constant space.

Another approach(Using Slicing ):

We can also solve this problem using slicing in python.  

Implementation for the above approach:-

C++

#include <iostream>
using namespace std;

void rotateArray(int array[], int size) {
    int last = array[size-1];
    for (int i = size-1; i > 0; i--) {
        array[i] = array[i-1];
    }
    array[0] = last;
}

int main() {
    int array[] = {1, 2, 3, 4, 5};
    int size = sizeof(array) / sizeof(array[0]);
    rotateArray(array, size);
    for (int i = 0; i < size; i++) {
        cout << array[i] << " ";
    }
    return 0;
}

Python3

def rotateArray(array):
    '''
    array[-1:] taking last element
    array[:-1] taking elements from start to last second element
    array[:] changing array from starting to end
    '''
    array[:] = array[-1:]+array[:-1]


# create array
array = [1, 2, 3, 4, 5]
# send array to rotateArray function
rotateArray(array)

print(*array)  # 5 1 2 3 4

Java

import java.util.Arrays;

public class Main {
    public static void rotateArray(int[] array, int size)
    {
        int last = array[size - 1];
        for (int i = size - 1; i > 0; i--) {
            array[i] = array[i - 1];
        }
        array[0] = last;
    }
    public static void main(String[] args)
    {
        int[] array = { 1, 2, 3, 4, 5 };
        int size = array.length;
        rotateArray(array, size);
        System.out.println(Arrays.toString(array));
    }
} // this code is contributed by devendrasalunke

Javascript

function rotateArray(array) {
    const last = array[array.length - 1]; // Store the last element of the array
    for (let i = array.length - 1; i > 0; i--) {
        array[i] = array[i - 1]; // Shift each element to the right by one
    }
    array[0] = last; // Replace the first element with the stored last element
}

const array = [1, 2, 3, 4, 5];
rotateArray(array);
console.log(array); // Output: [5, 1, 2, 3, 4]

C#

using System;

class Program {
    // Define a method to rotate an array to the right by one position
    static void RotateArray(int[] array, int size) {
        // Store the last element of the array
        int last = array[size - 1];
        // Iterate through the array from the second to last element to the first
        for (int i = size - 1; i > 0; i--) {
            // Move each element one position to the right
            array[i] = array[i - 1];
        }
        // Move the last element to the first position of the array
        array[0] = last;
    }

    static void Main(string[] args) {
        // Declare an array of integers
        int[] array = { 1, 2, 3, 4, 5 };
        // Get the length of the array
        int size = array.Length;
        // Rotate the array to the right by one position
        RotateArray(array, size);
        // Print the elements of the rotated array to the console
        for (int i = 0; i < size; i++) {
            Console.Write($"{array[i]} ");
        }
    }
}

Output

5 1 2 3 4

Time Complexity: O(n), as we are reversing the array. Where n is the number of elements in the array.
Auxiliary Space: O(1), as we are using constant space.

Another approach(Using Reversal Algorithm ):

The idea is to reverse the array two times. First time we will reverse the first n-1(n=size of array) elements. Finally, we will get our rotated array by reversing the entire array.

C++

// C++ program to cyclically rotate an array by one
#include <iostream>
using namespace std;
int main()
{
    int arr[] = { 1,2,3,4,5};
    int n = sizeof(arr) / sizeof(arr[0]);
    int k = 1; //No. of rotations
    int i, j;

    cout << "Given array is \n";
    for (i = 0; i < n; i++)
        cout << arr[i] << " ";


    // Reverse the first n-1 terms
    for (i = 0, j = n - k - 1; i < j; i++, j--) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
    // Reverse the entire array
    for (i = 0, j = n - 1; i < j; i++, j--) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    cout << "\nRotated array is\n";
    for (i = 0; i < n; i++)
        cout << arr[i] << " ";

    return 0;
}

Java

// Java program to cyclically rotate an array by one
import java.util.*;

class Main {
    public static void main(String[] args)
    {
        int[] arr = { 1, 2, 3, 4, 5 };
        int n = arr.length;
        int k = 1; // No. of rotations
        int i, j;
        System.out.println("Given array is ");
        for (i = 0; i < n; i++)
            System.out.print(arr[i] + " ");

        // Reverse the first n-1 terms
        for (i = 0, j = n - k - 1; i < j; i++, j--) {
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }

        // Reverse the entire array
        for (i = 0, j = n - 1; i < j; i++, j--) {
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }

        System.out.println("\nRotated array is");
        for (i = 0; i < n; i++)
            System.out.print(arr[i] + " ");
    }
}

C#

using System;

class Program
{
    static void Main(string[] args)
    {
        int[] arr = { 1, 2, 3, 4, 5 };
        int n = arr.Length;
        int k = 1; //No. of rotations
        int i, j;

        Console.WriteLine("Given array is:");
        for (i = 0; i < n; i++)
            Console.Write(arr[i] + " ");

        // Reverse the first n-1 terms
        for (i = 0, j = n - k - 1; i < j; i++, j--)
        {
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }

        // Reverse the entire array
        for (i = 0, j = n - 1; i < j; i++, j--)
        {
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }

        Console.WriteLine("\nRotated array is:");
        for (i = 0; i < n; i++)
            Console.Write(arr[i] + " ");

        Console.ReadLine();
    }
}
// This code is contributed by Prajwal Kandekar

Javascript

let arr = [1, 2, 3, 4, 5];
let n = arr.length;
let k = 1; // No. of rotations
let i, j;

console.log("Given array is");
for (i = 0; i < n; i++) {
    process.stdout.write(arr[i] + " ");
}

// Reverse the first n-1 terms
for (i = 0, j = n - k - 1; i < j; i++, j--) {
    let temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}
// Reverse the entire array
for (i = 0, j = n - 1; i < j; i++, j--) {
    let temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

console.log("\nRotated array is");
console.log();
for (i = 0; i < n; i++) {
    process.stdout.write(arr[i] + " ");
}

Output

Given array is 
1 2 3 4 5 
Rotated array is
5 1 2 3 4 

Time Complexity: O(n), as we are reversing the array. Where n is the number of elements in the array.
Auxiliary Space: O(1), as we are using constant space.