Clockwise rotation of Linked List - GeeksforGeeks

31 Mar, 2022
Given a singly linked list and an integer K, the task is to rotate the linked list clockwise to the right by K places.Examples:  
Input: 1 -> 2 -> 3 -> 4 -> 5 -> NULL, K = 2 Output: 4 -> 5 -> 1 -> 2 -> 3 -> NULLInput: 7 -> 9 -> 11 -> 13 -> 3 -> 5 -> NULL, K = 12 Output: 7 -> 9 -> 11 -> 13 -> 3 -> 5 -> NULL  
 
Approach: To rotate the linked list first check whether the given k is greater than the count of nodes in the linked list or not. Traverse the list and find the length of the linked list then compare it with k, if less then continue otherwise deduce it in the range of linked list size by taking modulo with the length of the list. After that subtract the value of k from the length of the list. Now, the question has been changed to the left rotation of the linked list so follow that procedure:  
Change the next of the kth node to NULL.
Change the next of the last node to the previous head node.
Change the head to (k+1)th node.
In order to do that, the pointers to the kth node, (k+1)th node, and last node are required.Below is the implementation of the above approach:  
C++
Java
Python3
C#
Javascript
// C++ implementation of the approach#include <bits/stdc++.h>using namespace std; /* Link list node */class Node {public:    int data;    Node* next;}; /* A utility function to push a node */void push(Node** head_ref, int new_data){    /* allocate node */    Node* new_node = new Node();     /* put in the data */    new_node->data = new_data;     /* link the old list off the new node */    new_node->next = (*head_ref);     /* move the head to point to the new node */    (*head_ref) = new_node;} /* A utility function to print linked list */void printList(Node* node){    while (node != NULL) {        cout << node->data << " -> ";        node = node->next;    }    cout << "NULL";} // Function that rotates the given linked list// clockwise by k and returns the updated// head pointerNode* rightRotate(Node* head, int k){     // If the linked list is empty    if (!head)        return head;     // len is used to store length of the linked list    // tmp will point to the last node after this loop    Node* tmp = head;    int len = 1;    while (tmp->next != NULL) {        tmp = tmp->next;        len++;    }     // If k is greater than the size    // of the linked list    if (k > len)        k = k % len;     // Subtract from length to convert    // it into left rotation    k = len - k;     // If no rotation needed then    // return the head node    if (k == 0 || k == len)        return head;     // current will either point to    // kth or NULL after this loop    Node* current = head;    int cnt = 1;    while (cnt < k && current != NULL) {        current = current->next;        cnt++;    }     // If current is NULL then k is equal to the    // count of nodes in the list    // Don't change the list in this case    if (current == NULL)        return head;     // current points to the kth node    Node* kthnode = current;     // Change next of last node to previous head    tmp->next = head;     // Change head to (k+1)th node    head = kthnode->next;     // Change next of kth node to NULL    kthnode->next = NULL;     // Return the updated head pointer    return head;} // Driver codeint main(){     /* The constructed linked list is:    1->2->3->4->5 */    Node* head = NULL;    push(&head, 5);    push(&head, 4);    push(&head, 3);    push(&head, 2);    push(&head, 1);     int k = 2;     // Rotate the linked list    Node* updated_head = rightRotate(head, k);     // Print the rotated linked list    printList(updated_head);     return 0;}
// Java implementation of the approachclass GFG{     /* Link list node */static class Node{    int data;    Node next;} /* A utility function to push a node */static Node push(Node head_ref, int new_data){    /* allocate node */    Node new_node = new Node();     /* put in the data */    new_node.data = new_data;     /* link the old list off the new node */    new_node.next = (head_ref);     /* move the head to point to the new node */    (head_ref) = new_node;    return head_ref;} /* A utility function to print linked list */static void printList(Node node){    while (node != null)    {        System.out.print(node.data + " -> ");        node = node.next;    }    System.out.print( "null");} // Function that rotates the given linked list// clockwise by k and returns the updated// head pointerstatic Node rightRotate(Node head, int k){     // If the linked list is empty    if (head == null)        return head;     // len is used to store length of the linked list    // tmp will point to the last node after this loop    Node tmp = head;    int len = 1;    while (tmp.next != null)    {        tmp = tmp.next;        len++;    }     // If k is greater than the size    // of the linked list    if (k > len)        k = k % len;     // Subtract from length to convert    // it into left rotation    k = len - k;     // If no rotation needed then    // return the head node       if (k == 0 || k == len)        return head;     // current will either point to    // kth or null after this loop    Node current = head;    int cnt = 1;    while (cnt < k && current != null)    {        current = current.next;        cnt++;    }     // If current is null then k is equal to the    // count of nodes in the list    // Don't change the list in this case    if (current == null)        return head;     // current points to the kth node    Node kthnode = current;     // Change next of last node to previous head    tmp.next = head;     // Change head to (k+1)th node    head = kthnode.next;     // Change next of kth node to null    kthnode.next = null;     // Return the updated head pointer    return head;} // Driver codepublic static void main(String args[]){     /* The constructed linked list is:    1.2.3.4.5 */    Node head = null;    head = push(head, 5);    head = push(head, 4);    head = push(head, 3);    head = push(head, 2);    head = push(head, 1);     int k = 2;     // Rotate the linked list    Node updated_head = rightRotate(head, k);     // Print the rotated linked list    printList(updated_head);}} // This code is contributed by Arnub Kundu
# Python3 implementation of the approach ''' Link list node '''class Node:     def __init__(self, data):        self.data = data        self.next = None ''' A utility function to push a node '''def push(head_ref, new_data):       ''' allocate node '''    new_node = Node(new_data)     ''' put in the data '''    new_node.data = new_data     ''' link the old list off the new node '''    new_node.next = (head_ref)     ''' move the head to point to the new node '''    (head_ref) = new_node     return head_ref ''' A utility function to print linked list '''def printList(node):    while (node != None):        print(node.data, end=' -> ')        node = node.next    print("NULL") # Function that rotates the given linked list# clockwise by k and returns the updated# head pointerdef rightRotate(head, k):     # If the linked list is empty    if (not head):        return head     # len is used to store length of the linked list    # tmp will point to the last node after this loop    tmp = head    len = 1     while (tmp.next != None):        tmp = tmp.next        len += 1     # If k is greater than the size    # of the linked list    if (k > len):        k = k % len     # Subtract from length to convert    # it into left rotation    k = len - k     # If no rotation needed then    # return the head node    if (k == 0 or k == len):        return head     # current will either point to    # kth or None after this loop    current = head    cnt = 1     while (cnt < k and current != None):        current = current.next        cnt += 1     # If current is None then k is equal to the    # count of nodes in the list    # Don't change the list in this case    if (current == None):        return head     # current points to the kth node    kthnode = current     # Change next of last node to previous head    tmp.next = head     # Change head to (k+1)th node    head = kthnode.next     # Change next of kth node to None    kthnode.next = None     # Return the updated head pointer    return head  # Driver codeif __name__ == '__main__':     ''' The constructed linked list is:    1.2.3.4.5 '''    head = None    head = push(head, 5)    head = push(head, 4)    head = push(head, 3)    head = push(head, 2)    head = push(head, 1)    k = 2     # Rotate the linked list    updated_head = rightRotate(head, k)     # Print the rotated linked list    printList(updated_head)         # This code is contributed by rutvik_56
// C# implementation of the approachusing System; class GFG{     /* Link list node */public class Node{    public int data;    public Node next;} /* A utility function to push a node */static Node push(Node head_ref,                 int new_data){    /* allocate node */    Node new_node = new Node();     /* put in the data */    new_node.data = new_data;     /* link the old list off the new node */    new_node.next = (head_ref);     /* move the head to point    to the new node */    (head_ref) = new_node;    return head_ref;} /* A utility function to print linked list */static void printList(Node node){    while (node != null)    {        Console.Write(node.data + " -> ");        node = node.next;    }    Console.Write("null");} // Function that rotates the given linked list// clockwise by k and returns the updated// head pointerstatic Node rightRotate(Node head, int k){     // If the linked list is empty    if (head == null)        return head;     // len is used to store length of    // the linked list, tmp will point    // to the last node after this loop    Node tmp = head;    int len = 1;    while (tmp.next != null)    {        tmp = tmp.next;        len++;    }     // If k is greater than the size    // of the linked list    if (k > len)        k = k % len;     // Subtract from length to convert    // it into left rotation    k = len - k;     // If no rotation needed then    // return the head node       if (k == 0 || k == len)        return head;     // current will either point to    // kth or null after this loop    Node current = head;    int cnt = 1;    while (cnt < k && current != null)    {        current = current.next;        cnt++;    }     // If current is null then k is equal    // to the count of nodes in the list    // Don't change the list in this case    if (current == null)        return head;     // current points to the kth node    Node kthnode = current;     // Change next of last node    // to previous head    tmp.next = head;     // Change head to (k+1)th node    head = kthnode.next;     // Change next of kth node to null    kthnode.next = null;     // Return the updated head pointer    return head;} // Driver codepublic static void Main(String []args){     /* The constructed linked list is:    1.2.3.4.5 */    Node head = null;    head = push(head, 5);    head = push(head, 4);    head = push(head, 3);    head = push(head, 2);    head = push(head, 1);     int k = 2;     // Rotate the linked list    Node updated_head = rightRotate(head, k);     // Print the rotated linked list    printList(updated_head);}} // This code is contributed by PrinciRaj1992
<script> // JavaScript implementation of the approach    /* Link list node */ class Node {        constructor() {            this.data = 0;            this.next = null;        }    }     /* A utility function to push a node */    function push(head_ref , new_data) {        /* allocate node */      var new_node = new Node();         /* put in the data */        new_node.data = new_data;         /* link the old list off the new node */        new_node.next = (head_ref);         /* move the head to point to the new node */        (head_ref) = new_node;        return head_ref;    }     /* A utility function to print linked list */    function printList(node) {        while (node != null) {            document.write(node.data + " -> ");            node = node.next;        }        document.write("null");    }     // Function that rotates the given linked list    // clockwise by k and returns the updated    // head pointer    function rightRotate(head , k) {         // If the linked list is empty        if (head == null)            return head;         // len is used to store length        // of the linked list        // tmp will point to the last        // node after this loop        var tmp = head;        var len = 1;        while (tmp.next != null) {            tmp = tmp.next;            len++;        }         // If k is greater than the size        // of the linked list        if (k > len)            k = k % len;         // Subtract from length to convert        // it into left rotation        k = len - k;         // If no rotation needed then        // return the head node        if (k == 0 || k == len)            return head;         // current will either point to        // kth or null after this loop        var current = head;        var cnt = 1;        while (cnt < k && current != null) {            current = current.next;            cnt++;        }         // If current is null then k is equal to the        // count of nodes in the list        // Don't change the list in this case        if (current == null)            return head;         // current points to the kth node        var kthnode = current;         // Change next of last node to previous head        tmp.next = head;         // Change head to (k+1)th node        head = kthnode.next;         // Change next of kth node to null        kthnode.next = null;         // Return the updated head pointer        return head;    }     // Driver code              /*         * The constructed linked list is: 1.2.3.4.5         */        var head = null;        head = push(head, 5);        head = push(head, 4);        head = push(head, 3);        head = push(head, 2);        head = push(head, 1);         var k = 2;         // Rotate the linked list        var updated_head = rightRotate(head, k);         // Print the rotated linked list        printList(updated_head); // This code contributed by Rajput-Ji </script>
4 -> 5 -> 1 -> 2 -> 3 -> NULL
 
Time Complexity: O(n) where n is the number of nodes in Linked List.
Auxiliary Space: O(1)
STL based approach : 
This problem can also be solved using the deque data structure provided in the C++ STL
Approach : 
Initialise a deque with the type Node* and push the linked list into it.Then keep popping from it’s back and adding that node to it’s front until the number of operations are not equal to k.
C++
#include <bits/stdc++.h>using namespace std;class Node {public:    int val;    Node* next;    Node(int d)    {        val = d;        next = NULL;    }};void build(Node*& head, int val){    if (head == NULL) {        head = new Node(val);    }    else {        Node* temp = head;        while (temp->next != NULL) {            temp = temp->next;        }        temp->next = new Node(val);    }}Node* rotate_clockwise(Node* head, int k){    if (head == NULL) {        return NULL;    }    deque<Node*> q;    Node* temp = head;    while (temp != NULL) {        q.push_back(temp);        temp = temp->next;    }    k %= q.size();    while (        k--) // popping from back and adding to it's front    {        q.back()->next = q.front();        q.push_front(q.back());        q.pop_back();        q.back()->next = NULL;    }    return q.front();}void print(Node* head){    while (head != NULL) {        cout << head->val << " -> ";        head = head->next;    }    cout << "NULL";    cout << endl;}int main(){    Node* head = NULL;    build(head, 1);    build(head, 2);    build(head, 3);    build(head, 4);    build(head, 5);    int k = 2;    Node* r = rotate_clockwise(head, k);    print(r);    return 0;}
4 -> 5 -> 1 -> 2 -> 3 -> NULL
Time Complexity: O(N)
Auxiliary Space: O(N) 
andrew1234
princiraj1992
rutvik_56
Rajput-Ji
adityamutharia
simranarora5sos
rohitsingh57
Linked Lists
rotation
Data Structures
Linked List
Data Structures
Linked List
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
SDE SHEET - A Complete Guide for SDE Preparation
DSA Sheet by Love Babbar
Introduction to Algorithms
How to Start Learning DSA?
Hash Map in Python
Linked List | Set 1 (Introduction)
Linked List | Set 2 (Inserting a node)
Stack Data Structure (Introduction and Program)
Linked List | Set 3 (Deleting a node)
LinkedList in Java