Open in App
Not now

# Program to cyclically rotate an array by one

• Difficulty Level : Basic
• Last Updated : 25 Mar, 2023

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 ` `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 `   `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

 ` 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

 ``

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 `   `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 ` `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

 ``

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 ` `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 ` `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.

My Personal Notes arrow_drop_up
Related Articles