# Rotate List Leetcode Solution

Difficulty Level Medium
algorithms coding Interview interviewprep LeetCode LeetCodeSolutions Linked-List Two Pointers

The problem Rotate List Leetcode Solution provides us a linked list and an integer. We are told to rotate the linked list to the right by k places. So if we rotate a linked list k places to the right, in each step we take the last element from the list and place it in from. We repeat this until we have done k number of these operations. Let’s take a look at a few examples.

`head = [1,2,3,4,5], k = 2`
`[4,5,1,2,3]`

Explanation: Let’s break the operation into 2 simple rotation operations. So, in the first step or move, we simply take the element from the end of the list and place it in front. So, the list becomes [5, 1, 2, 3, 4]. Now, again we repeat the same operation making the list, [4, 5, 1, 2, 3]. And hence the answer.

`head = [0,1,2], k = 4`
`[2, 0, 1]`

Explanation: Repeating the process 4 times result in the answer linked list. It can be better understood by looking at the image below. ## Approach for Rotate List Leetcode Solution

The problem Rotate List Leetcode Solution states that you are given a linked list with an integer for rotation. This means that we need to rotate the list k places to the right. The problem can be understood by a simple operation of taking the elements from the end of the list and placing them in front. Since there is no way to efficiently remove an element from the end and place it in front. We need to think of any other way to perform the operation. If we observe, we can see that after performing k operations, k elements from the end are removed and are placed in front. One thing to note here is, if the size of k is greater than the size of the linked list. We will take the modulo of k over the length of the linked list.

Contiguous Array Leetcode

Once done, we will traverse until the kth node from the end. Then we perform some of the operations, we assign the next of the last node to the head. Assign the kth node from the end as head of the linked list. But we should not forget assigning the next node of k-1 th node from the end as null. Now, after performing these 3 operations, we have rotated the list.

## Code for Rotate List Leetcode Solution

### C++ code

```#include <bits/stdc++.h>
using namespace std;

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

ListNode* rotateRight(ListNode* head, int k) {

int cnt = 0;
while(tmp)tmp=tmp->next,cnt++;
k%=cnt;

while(k--)tmp = tmp->next;
while(tmp->next!=NULL){
tmp = tmp->next;
}
}

int main(){

}
}
```
`2 0 1`

### Java Code

```import java.util.*;
import java.lang.*;
import java.io.*;

class ListNode{
int data;
ListNode next;
}

class Solution {
public static ListNode rotateRight(ListNode head, int k) {

int cnt = 0;
while(tmp != null){
tmp=tmp.next;
cnt++;
}
k %= cnt;

while(k-- > 0)
tmp = tmp.next;
while(tmp.next != null){
tmp = tmp.next;
}
}

public static void main(String[] args){

}
}
}```
`2 0 1`

## Complexity Analysis

### Time Complexity

O(N), where N represents the size of the linked list. Since we have to traverse the linked list, the time complexity is linear and is dependent on the size of the list.