Rotate List

Rotate List - Problem

Given the head of a linked list, rotate the list to the right by k places.

When we rotate to the right by k places, the last k nodes from the end become the first k nodes at the beginning, and the remaining nodes shift to the right.

Example: If we have list 1→2→3→4→5 and rotate by 2 places, the result is 4→5→1→2→3. The last 2 nodes (4,5) moved to the front.

Input & Output

Example 1 — Basic Rotation

$ Input: head = [1,2,3,4,5], k = 2

› Output: [4,5,1,2,3]

💡 Note: Rotating right by 2 means the last 2 nodes (4,5) move to the front: 1→2→3→4→5 becomes 4→5→1→2→3

Example 2 — Single Rotation

$ Input: head = [0,1,2], k = 4

› Output: [2,0,1]

💡 Note: k=4 with length=3, so effective rotation is 4%3=1. Move last node to front: 0→1→2 becomes 2→0→1

Example 3 — No Rotation Needed

$ Input: head = [1], k = 1

› Output: [1]

💡 Note: Single node list remains unchanged regardless of k value

Constraints

The number of nodes in the list is in the range [0, 500]
-100 ≤ Node.val ≤ 100
0 ≤ k ≤ 2×10⁹

Visualization

Tap to expand

Asked in

G Google 42 a Amazon 38 M Microsoft 25 f Facebook 22

Brief HTML summary: The key insight is to make the list circular first, then break it at the calculated position. Best approach uses circular connection technique. Time: O(n), Space: O(1)

Common Approaches

✓ Brute Force - Move One by One

⏱️ Time: O(k×n) Space: O(1)

For each rotation, find the last node, move it to the front, and update connections. Repeat this k times until we achieve the desired rotation.

Optimized - Connect and Break

⏱️ Time: O(n) Space: O(1)

First find the length of the list and make it circular. Then calculate the actual rotation needed (k % length) and break the circle at the correct position to get the rotated list.

Brute Force - Move One by One — Algorithm Steps

Step 1: For each of k rotations
Step 2: Find the last node and second-to-last node
Step 3: Move last node to front and update connections

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial List

Start with original list 1→2→3→4→5

Move Tail k Times

Each rotation moves last node to front

Final Result

After k rotations: 4→5→1→2→3

Code -

solution.c — C

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

struct ListNode {
    int val;
    struct ListNode* next;
};

struct ListNode* solution(struct ListNode* head, int k) {
    if (head == NULL || head->next == NULL || k == 0) {
        return head;
    }
    
    // Perform k rotations
    for (int i = 0; i < k; i++) {
        // Find the last and second-to-last nodes
        struct ListNode* prev = NULL;
        struct ListNode* curr = head;
        while (curr->next) {
            prev = curr;
            curr = curr->next;
        }
        
        // Move last node to front
        if (prev) {
            prev->next = NULL;
            curr->next = head;
            head = curr;
        }
    }
    
    return head;
}

struct ListNode* arrayToList(int* arr, int size) {
    if (size == 0) return NULL;
    struct ListNode* head = (struct ListNode*)malloc(sizeof(struct ListNode));
    head->val = arr[0];
    head->next = NULL;
    struct ListNode* curr = head;
    for (int i = 1; i < size; i++) {
        curr->next = (struct ListNode*)malloc(sizeof(struct ListNode));
        curr->next->val = arr[i];
        curr->next->next = NULL;
        curr = curr->next;
    }
    return head;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array [1,2,3,4,5]
    int arr[100];
    int size = 0;
    char* token = strtok(line, "[,]\n");
    while (token != NULL) {
        if (token[0] >= '0' || token[0] == '-') {
            arr[size++] = atoi(token);
        }
        token = strtok(NULL, "[,]\n");
    }
    
    int k;
    scanf("%d", &k);
    
    struct ListNode* head = arrayToList(arr, size);
    struct ListNode* result = solution(head, k);
    
    printf("[");
    int first = 1;
    while (result) {
        if (!first) printf(",");
        printf("%d", result->val);
        result = result->next;
        first = 0;
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(k×n)

For each of k rotations, we traverse n nodes to find the tail

✓ Linear Growth

Space Complexity

O(1)

Only using a few pointer variables

✓ Linear Space

892.0K Views

Medium Frequency

~25 min Avg. Time

8.4K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Move One by One — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler