Rotate a Linked List

Rotate Array By One

Last Updated : 30 Dec, 2024

Try it on GfG Practice

Given an array, the task is to cyclically right-rotate the array by one.

Examples:

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

Table of Content

Shifting Each Element - O(n) Time and O(1) Space
Using Two Pointers - O(n) Time and O(1) Space
Reversing the Array - O(n) Time and O(1) Space

Shifting Each Element - O(n) Time and O(1) Space

The basic idea is to store the last element in a temp variable and shift every other element one position ahead. After shifting, update the first element with value stored in temp.

C++14

#include <iostream>
#include<vector>
using namespace std;

void rotate(vector<int> &arr) {
  int n = arr.size();
  
    // store the last element in a variable
    int lastElement = arr[n-1];

    // assign every value by its predecessor
    for (int i = n - 1; i > 0; i--) {
        arr[i] = arr[i - 1];
    }

    // first element will be assigned by last element
    arr[0] = lastElement;
}

int main() {
    vector<int> arr = {1, 2, 3, 4, 5 };

    rotate(arr);
    for (int i = 0; i < arr.size(); i++)
        cout << arr[i] << ' ';

    return 0;
}

C

#include <stdio.h>
#include <stdlib.h>

void rotate(int arr[], int n) {
  
    // store the last element in a variable
    int lastElement = arr[n-1];

    // assign every value by its predecessor
    for (int i = n - 1; i > 0; i--) {
        arr[i] = arr[i - 1];
    }

    // first element will be assigned by last element
    arr[0] = lastElement;
}

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

    rotate(arr, n);
    for (int i = 0; i < n; i++)
        printf("%d ", arr[i]);

    return 0;
}

Java

import java.util.Arrays;

class GfG {
    static void rotate(int[] arr) {
        // store the last element in a variable
        int lastElement = arr[arr.length - 1];

        // assign every value by its predecessor
        for (int i = arr.length - 1; i > 0; i--) {
            arr[i] = arr[i - 1];
        }

        // first element will be assigned by last element
        arr[0] = lastElement;
    }

    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};

        rotate(arr);
        System.out.println(Arrays.toString(arr));
    }
}

Python

def rotate(arr):
  
    # store the last element in a variable
    lastElement = arr[-1]

    # assign every value by its predecessor
    for i in range(len(arr) - 1, 0, -1):
        arr[i] = arr[i - 1]

    # first element will be assigned by last element
    arr[0] = lastElement

if __name__ == "__main__":
  arr = [1, 2, 3, 4, 5]
  rotate(arr)
  for i in range(0, len(arr)):
    print(arr[i], end=' ')

C#

using System;

class GfG {
    static void Rotate(int[] arr) {
      
        // store the last element in a variable
        int lastElement = arr[arr.Length - 1];

        // assign every value by its predecessor
        for (int i = arr.Length - 1; i > 0; i--) {
            arr[i] = arr[i - 1];
        }

        // first element will be assigned by last element
        arr[0] = lastElement;
    }

    static void Main() {
        int[] arr = {1, 2, 3, 4, 5};

        Rotate(arr);
        Console.WriteLine(string.Join(" ", arr));
    }
}

JavaScript

function rotate(arr) {
    // store the last element in a variable
    const lastElement = arr[arr.length - 1];

    // assign every value by its predecessor
    for (let i = arr.length - 1; i > 0; i--) {
        arr[i] = arr[i - 1];
    }

    // first element will be assigned by last element
    arr[0] = lastElement;
}

// Driver Code
const arr = [1, 2, 3, 4, 5];
rotate(arr);
console.log(arr);

Output

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.

Using Two Pointers - O(n) Time and O(1) Space

We can use two pointers, As we know in cyclic rotation we will bring last element to first and shift rest in forward direction, we can do this by swapping every element with last element till we get to the last point.

C++14

#include <iostream>
#include<vector>
using namespace std;

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

int main() {
 	vector<int> arr = {1, 2, 3, 4, 5 };
 	int i;
    rotate(arr);
    for (i = 0; i < arr.size(); i++)
        cout << arr[i] << " ";

    return 0;
}

C

#include <stdio.h>
#include <stdlib.h>

void rotate(int *arr, int n) {
  
    // 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++;
    }
}

int main() {
    int arr[] = {1, 2, 3, 4, 5};
    int n = sizeof(arr) / sizeof(arr[0]);
    rotate(arr, n);
    for (int i = 0; i < n; i++)
        printf("%d ", arr[i]);
    return 0;
}

Java

import java.util.Arrays;

class GfG {
    static void rotate(int[] arr) {
      
        // i and j pointing to first and last
        // element respectively
        int i = 0, j = arr.length - 1;
        while (i != j) {
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
            i++;
        }
    }

    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        rotate(arr);
        System.out.println(Arrays.toString(arr));
    }
}

Python

def rotate(arr):
  
    # i and j pointing to first and last
    # element respectively
    i, j = 0, len(arr) - 1
    while i != j:
        arr[i], arr[j] = arr[j], arr[i]
        i += 1

if __name__ == "__main__":
  arr = [1, 2, 3, 4, 5]
  rotate(arr)
  for i in range(0, len(arr)):
    print(arr[i], end=' ')

C#

using System;

class GfG {
    static void Rotate(int[] arr) {
      
        // i and j pointing to first and last
        // element respectively
        int i = 0, j = arr.Length - 1;
        while (i != j) {
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
            i++;
        }
    }

    static void Main() {
        int[] arr = {1, 2, 3, 4, 5};
        Rotate(arr);
        Console.WriteLine(string.Join(" ", arr));
    }
}

JavaScript

function rotate(arr) {

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

// Driver Code
let arr = [1, 2, 3, 4, 5];
rotate(arr);
console.log(arr);

Output

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.

Reversing the Array - O(n) Time and O(1) Space

We can use Reversal Algorithm also, reverse first n-1 elements and then whole array which will result into one right rotation.

C++14

#include <iostream>
#include<vector>
using namespace std;

void rotate(vector<int> &arr) {
  int n = arr.size();
  
    // Reverse the first n-1 terms
    int i, j;
    for (i = 0, j = n - 2; 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;
    }
}

int main() {
    vector<int> arr = {1, 2, 3, 4, 5 };
    int i, j;
    rotate(arr);
    for (i = 0; i < arr.size(); i++)
        cout << arr[i] << " ";

    return 0;
}

C

#include <stdio.h>
#include <stdlib.h>

void rotate(int *arr, int n) {
  
    // Reverse the first n-1 terms
    int i, j;
    for (i = 0, j = n - 2; 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;
    }
}

int main() {
    int arr[] = {1, 2, 3, 4, 5};
    int n = sizeof(arr) / sizeof(arr[0]);
    rotate(arr, n);
    for (int i = 0; i < n; i++)
        printf("%d ", arr[i]);
    return 0;
}

Java

import java.util.Arrays;

class GfG {
     static void rotate(int[] arr) {
        int n = arr.length;
       
        // Reverse the first n-1 terms
        for (int i = 0, j = n - 2; i < j; i++, j--) {
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
        
        // Reverse the entire array
        for (int i = 0, j = n - 1; i < j; i++, j--) {
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
    }

    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        rotate(arr);
        System.out.println(Arrays.toString(arr));
    }
}

Python

def rotate(arr):
    n = len(arr)
    
    # Reverse the first n-1 terms
    i, j = 0, n - 2
    while i < j:
        arr[i], arr[j] = arr[j], arr[i]
        i += 1
        j -= 1
    
    # Reverse the entire array
    i, j = 0, n - 1
    while i < j:
        arr[i], arr[j] = arr[j], arr[i]
        i += 1
        j -= 1

if __name__ == "__main__":
  arr = [1, 2, 3, 4, 5]
  rotate(arr)
  for i in range(0, len(arr)):
    print(arr[i], end=' ')

C#

using System;

class GfG {
    static void Rotate(int[] arr) {
        int n = arr.Length;
      
        // Reverse the first n-1 terms
        for (int i = 0, j = n - 2; i < j; i++, j--) {
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
        
        // Reverse the entire array
        for (int i = 0, j = n - 1; i < j; i++, j--) {
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
    }

    static void Main() {
        int[] arr = {1, 2, 3, 4, 5};
        Rotate(arr);
        Console.WriteLine(string.Join(" ", arr));
    }
}

JavaScript

function rotate(arr) {
    const n = arr.length;
    
    // Reverse the first n-1 terms
    for (let i = 0, j = n - 2; i < j; i++, j--) {
        [arr[i], arr[j]] = [arr[j], arr[i]];
    }
    
    // Reverse the entire array
    for (let i = 0, j = n - 1; i < j; i++, j--) {
        [arr[i], arr[j]] = [arr[j], arr[i]];
    }
}

// Driver Code
const arr = [1, 2, 3, 4, 5];
rotate(arr);
console.log(arr);

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.

Rotate a Linked List

kartik

Improve

Article Tags :

Practice Tags :

Arrays

Similar Reads

Rotate bits of a number

Given a 32-bit integer n and an integer d, rotate the binary representation of n by d positions in both left and right directions. After each rotation, convert the result back to its decimal representation and return both values in an array as [left rotation, right rotation].Note: A rotation (or cir

Rotate an Array by d - Counterclockwise or Left

Given an array of integers arr[] of size n, the task is to rotate the array elements to the left by d positions.Examples:Input: arr[] = {1, 2, 3, 4, 5, 6}, d = 2Output: {3, 4, 5, 6, 1, 2}Explanation: After first left rotation, arr[] becomes {2, 3, 4, 5, 6, 1} and after the second rotation, arr[] bec

Rotate an Array - Clockwise or Right

Rotations in the array is defined as the process of rearranging the elements in an array by shifting each element to a new position. This is mostly done by rotating the elements of the array clockwise or counterclockwise.Table of ContentTypes of Rotations in ArrayHow to implement rotations in an arr

Sort a Rotated Sorted Array

You are given a rotated sorted array and your aim is to restore its original sort in place.Expected to use O(1) extra space and O(n) time complexity. Examples: Input : [3, 4, 1, 2] Output : [1, 2, 3, 4] Input : [2, 3, 4, 1] Output : [1, 2, 3, 4] We find the point of rotation. Then we rotate array us

Rotate a Linked List

Given a singly linked list and an integer k, the task is to rotate the linked list to the left by k places.Examples:Input: linked list = 10 -> 20 -> 30 -> 40 -> 50, k = 4Output: 50 -> 10 -> 20 -> 30 -> 40 Explanation: After rotating the linked list to the left by 4 places, th

Rotate Matrix Clockwise by 1

Given a square matrix, the task is to rotate its elements clockwise by one step.Examples:Input 1 2 34 5 6 7 8 9Output: 4 1 27 5 3 8 9 6Input: 1 2 3 4 5 6 7 8 9 10 11 1213 14 15 16 Output: 5 1 2 3 9 10 6 4 13 11 7 8 14 15 16 12The idea is to use nested loops to move elements in four directions (right

Rearrange Array Elements by Sign

Given an array arr[] of size n, the task is to rearrange it in alternate positive and negative manner without changing the relative order of positive and negative numbers. In case of extra positive/negative numbers, they appear at the end of the array.Note: The rearranged array should start with a p

Rotate a Matrix by 180 degree

Given a square matrix, the task is to turn it by 180 degrees. Note that when we rotate a matrix by 180 degree, clockwise and anticlockwise both give same results. Examples: Input: mat[][] = [[1, 2, 3] [4, 5, 6] [7, 8, 9]]Output: [9, 8, 7] [6, 5, 4] [3, 2, 1]Input: mat[][] = [[1, 2, 3, 4], [5, 6, 7,

Rotation Count in a Rotated Sorted array

Given an array arr[] having distinct numbers sorted in increasing order and the array has been right rotated (i.e, the last element will be cyclically shifted to the starting position of the array) k number of times, the task is to find the value of k.Examples: Input: arr[] = {15, 18, 2, 3, 6, 12}Ou

Rotate-matrix module in Python

The rotate-matrix is an interesting new python module, which allows conversion of a matrix(2-D array) into either clockwise rotation or anti-clockwise rotation. It at present consists of only two methods. You can loop through these methods for 'n' number of rotations. Installation This module doesn'