Rotate a Linked List

24 Jun, 2022
Given a singly linked list, rotate the linked list counter-clockwise by k nodes. Where k is a given positive integer. For example, if the given linked list is 10->20->30->40->50->60 and k is 4, the list should be modified to 50->60->10->20->30->40. Assume that k is smaller than the count of nodes in a linked list.
Method-1:To rotate the linked list, we need to change the next pointer of kth node to NULL, the next pointer of the last node should point to previous head node, and finally, change the head to (k+1)th node. So we need to get hold of three nodes: kth node, (k+1)th node, and last node. Traverse the list from the beginning and stop at kth node. Store pointer to kth node. We can get (k+1)th node using kthNode->next. Keep traversing till the end and store a pointer to the last node also. Finally, change pointers as stated above.
Below image shows how to rotate function works in the code :
C++
C
Java
Python
C#
Javascript
// C++ program to rotate// a linked list counter clock wise  #include <bits/stdc++.h>using namespace std;  /* Link list node */class Node {public:    int data;    Node* next;};  // This function rotates a linked list// counter-clockwise and updates the// head. The function assumes that k is// smaller than size of linked list.// It doesn't modify the list if// k is greater than or equal to sizevoid rotate(Node** head_ref, int k){    if (k == 0)        return;      // Let us understand the below    // code for example k = 4 and    // list = 10->20->30->40->50->60.    Node* current = *head_ref;      // current will either point to    // kth or NULL after this loop.    // current will point to node    // 40 in the above example    int count = 1;    while (count < k && current != NULL) {        current = current->next;        count++;    }      // If current is NULL, k is greater than    // or equal to count of nodes in linked list.    // Don't change the list in this case    if (current == NULL)        return;      // current points to kth node.    // Store it in a variable. kthNode    // points to node 40 in the above example    Node* kthNode = current;      // current will point to    // last node after this loop    // current will point to    // node 60 in the above example    while (current->next != NULL)        current = current->next;      // Change next of last node to previous head    // Next of 60 is now changed to node 10    current->next = *head_ref;      // Change head to (k+1)th node    // head is now changed to node 50    *head_ref = kthNode->next;      // change next of kth node to NULL    // next of 40 is now NULL    kthNode->next = NULL;}  /* UTILITY FUNCTIONS *//* 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;}  /* Function to print linked list */void printList(Node* node){    while (node != NULL) {        cout << node->data << " ";        node = node->next;    }}  /* Driver code*/int main(void){    /* Start with the empty list */    Node* head = NULL;      // create a list 10->20->30->40->50->60    for (int i = 60; i > 0; i -= 10)        push(&head, i);      cout << "Given linked list \n";    printList(head);    rotate(&head, 4);      cout << "\nRotated Linked list \n";    printList(head);      return (0);}  // This code is contributed by rathbhupendra
// C program to rotate a linked list counter clock wise  #include <stdio.h>#include <stdlib.h>  /* Link list node */struct Node {    int data;    struct Node* next;};  // This function rotates a linked list counter-clockwise and// updates the head. The function assumes that k is smaller// than size of linked list. It doesn't modify the list if// k is greater than or equal to sizevoid rotate(struct Node** head_ref, int k){    if (k == 0)        return;      // Let us understand the below code for example k = 4 and    // list = 10->20->30->40->50->60.    struct Node* current = *head_ref;      // current will either point to kth or NULL after this loop.    // current will point to node 40 in the above example    int count = 1;    while (count < k && current != NULL) {        current = current->next;        count++;    }      // If current is NULL, k is greater than or equal to count    // of nodes in linked list. Don't change the list in this case    if (current == NULL)        return;      // current points to kth node. Store it in a variable.    // kthNode points to node 40 in the above example    struct Node* kthNode = current;      // current will point to last node after this loop    // current will point to node 60 in the above example    while (current->next != NULL)        current = current->next;      // Change next of last node to previous head    // Next of 60 is now changed to node 10    current->next = *head_ref;      // Change head to (k+1)th node    // head is now changed to node 50    *head_ref = kthNode->next;      // change next of kth node to NULL    // next of 40 is now NULL    kthNode->next = NULL;}  /* UTILITY FUNCTIONS *//* Function to push a node */void push(struct Node** head_ref, int new_data){    /* allocate node */    struct Node* new_node = (struct Node*)malloc(sizeof(struct 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;}  /* Function to print linked list */void printList(struct Node* node){    while (node != NULL) {        printf("%d ", node->data);        node = node->next;    }}  /* Driver program to test above function*/int main(void){    /* Start with the empty list */    struct Node* head = NULL;      // create a list 10->20->30->40->50->60    for (int i = 60; i > 0; i -= 10)        push(&head, i);      printf("Given linked list \n");    printList(head);    rotate(&head, 4);      printf("\nRotated Linked list \n");    printList(head);      return (0);}
// Java program to rotate a linked list  class LinkedList {    Node head; // head of list      /* Linked list Node*/    class Node {        int data;        Node next;        Node(int d)        {            data = d;            next = null;        }    }      // This function rotates a linked list counter-clockwise    // and updates the head. The function assumes that k is    // smaller than size of linked list. It doesn't modify    // the list if k is greater than or equal to size    void rotate(int k)    {        if (k == 0)            return;          // Let us understand the below code for example k = 4        // and list = 10->20->30->40->50->60.        Node current = head;          // current will either point to kth or NULL after this        // loop. current will point to node 40 in the above example        int count = 1;        while (count < k && current != null) {            current = current.next;            count++;        }          // If current is NULL, k is greater than or equal to count        // of nodes in linked list. Don't change the list in this case        if (current == null)            return;          // current points to kth node. Store it in a variable.        // kthNode points to node 40 in the above example        Node kthNode = current;          // current will point to last node after this loop        // current will point to node 60 in the above example        while (current.next != null)            current = current.next;          // Change next of last node to previous head        // Next of 60 is now changed to node 10          current.next = head;          // Change head to (k+1)th node        // head is now changed to node 50        head = kthNode.next;          // change next of kth node to null        kthNode.next = null;    }      /*  Given a reference (pointer to pointer) to the head        of a list and an int, push a new node on the front        of the list. */    void push(int new_data)    {        /* 1 & 2: Allocate the Node &                  Put in the data*/        Node new_node = new Node(new_data);          /* 3. Make next of new Node as head */        new_node.next = head;          /* 4. Move the head to point to new Node */        head = new_node;    }      void printList()    {        Node temp = head;        while (temp != null) {            System.out.print(temp.data + " ");            temp = temp.next;        }        System.out.println();    }      /* Driver program to test above functions */    public static void main(String args[])    {        LinkedList llist = new LinkedList();          // create a list 10->20->30->40->50->60        for (int i = 60; i >= 10; i -= 10)            llist.push(i);          System.out.println("Given list");        llist.printList();          llist.rotate(4);          System.out.println("Rotated Linked List");        llist.printList();    }} /* This code is contributed by Rajat Mishra */
# Python program to rotate a linked list  # Node class class Node:      # Constructor to initialize the node object    def __init__(self, data):        self.data = data        self.next = None  class LinkedList:      # Function to initialize head    def __init__(self):        self.head = None      # Function to insert a new node at the beginning    def push(self, new_data):        # allocate node and put the data        new_node = Node(new_data)          # Make next of new node as head        new_node.next = self.head                  # move the head to point to the new Node        self.head = new_node      # Utility function to print it the linked LinkedList    def printList(self):        temp = self.head        while(temp):            print temp.data,            temp = temp.next      # This function rotates a linked list counter-clockwise and     # updates the head. The function assumes that k is smaller    # than size of linked list. It doesn't modify the list if    # k is greater than of equal to size    def rotate(self, k):        if k == 0:             return                   # Let us understand the below code for example k = 4        # and list = 10->20->30->40->50->60        current = self.head                  # current will either point to kth or NULL after        # this loop        # current will point to node 40 in the above example        count = 1         while(count <k and current is not None):            current = current.next            count += 1              # If current is None, k is greater than or equal         # to count of nodes in linked list. Don't change        # the list in this case        if current is None:            return          # current points to kth node. Store it in a variable        # kth node points to node 40 in the above example        kthNode = current               # current will point to last node after this loop        # current will point to node 60 in above example        while(current.next is not None):            current = current.next          # Change next of last node to previous head        # Next of 60 is now changed to node 10        current.next = self.head                  # Change head to (k + 1)th node        # head is not changed to node 50        self.head = kthNode.next          # change next of kth node to NULL         # next of 40 is not NULL         kthNode.next = None      # Driver program to test above functionllist = LinkedList()  # Create a list 10->20->30->40->50->60for i in range(60, 0, -10):    llist.push(i)  print "Given linked list"llist.printList()llist.rotate(4)  print "\nRotated Linked list"llist.printList()  # This code is contributed by Nikhil Kumar Singh(nickzuck_007)
// C# program to rotate a linked listusing System;  public class LinkedList {    Node head; // head of list      /* Linked list Node*/    public class Node {        public int data;        public Node next;        public Node(int d)        {            data = d;            next = null;        }    }      // This function rotates a linked list    // counter-clockwise and updates the head.    // The function assumes that k is smaller    // than size of linked list. It doesn't modify    // the list if k is greater than or equal to size    void rotate(int k)    {        if (k == 0)            return;          // Let us understand the below        // code for example k = 4        // and list = 10->20->30->40->50->60.        Node current = head;          // current will either point to kth        // or NULL after this loop. current        // will point to node 40 in the above example        int count = 1;        while (count < k && current != null) {            current = current.next;            count++;        }          // If current is NULL, k is greater than        // or equal to count of nodes in linked list.        // Don't change the list in this case        if (current == null)            return;          // current points to kth node.        // Store it in a variable.        // kthNode points to node        // 40 in the above example        Node kthNode = current;          // current will point to        // last node after this loop        // current will point to        // node 60 in the above example        while (current.next != null)            current = current.next;          // Change next of last node to previous head        // Next of 60 is now changed to node 10          current.next = head;          // Change head to (k+1)th node        // head is now changed to node 50        head = kthNode.next;          // change next of kth node to null        kthNode.next = null;    }      /* Given a reference (pointer to pointer) to the head        of a list and an int, push a new node on the front        of the list. */    void push(int new_data)    {        /* 1 & 2: Allocate the Node &                Put in the data*/        Node new_node = new Node(new_data);          /* 3. Make next of new Node as head */        new_node.next = head;          /* 4. Move the head to point to new Node */        head = new_node;    }      void printList()    {        Node temp = head;        while (temp != null) {            Console.Write(temp.data + " ");            temp = temp.next;        }        Console.WriteLine();    }      /* Driver code */    public static void Main()    {        LinkedList llist = new LinkedList();          // create a list 10->20->30->40->50->60        for (int i = 60; i >= 10; i -= 10)            llist.push(i);          Console.WriteLine("Given list");        llist.printList();          llist.rotate(4);          Console.WriteLine("Rotated Linked List");        llist.printList();    }}  /* This code contributed by PrinciRaj1992 */
<script>  // Javascript program to rotate a linked list  var head; // head of list      /* Linked list Node */     class Node {        constructor(val) {            this.data = val;            this.next = null;        }    }      // This function rotates a linked     // list counter-clockwise    // and updates the head.     // The function assumes that k is    // smaller than size of linked list.     // It doesn't modify    // the list if k is greater than or equal to size    function rotate(k) {        if (k == 0)            return;          // Let us understand the         // below code for example k = 4        // and list = 10->20->30->40->50->60.        var current = head;          // current will either point to kth         // or NULL after this        // loop. current will point to node         // 40 in the above example        var count = 1;        while (count < k && current != null) {            current = current.next;            count++;        }          // If current is NULL, k is greater        // than or equal to count        // of nodes in linked list.         // Don't change the list in this case        if (current == null)            return;          // current points to kth node.         // Store it in a variable.        // kthNode points to node 40         // in the above example        var kthNode = current;          // current will point to last        // node after this loop        // current will point to node         // 60 in the above example        while (current.next != null)            current = current.next;          // Change next of last node to previous head        // Next of 60 is now changed to node 10          current.next = head;          // Change head to (k+1)th node        // head is now changed to node 50        head = kthNode.next;          // change next of kth node to null        kthNode.next = null;    }      /*     * Given a reference (pointer to pointer) to        the head of a list and an int, push       a new node on the front of the list.     */    function push(new_data) {        /*         1 & 2: Allocate the Node & Put in the data         */   var new_node = new Node(new_data);          /* 3. Make next of new Node as head */        new_node.next = head;          /* 4. Move the head to point to new Node */        head = new_node;    }      function printList() {   var temp = head;        while (temp != null) {            document.write(temp.data + " ");            temp = temp.next;        }        document.write("<br/>");    }      /* Driver program to test above functions */              // create a list 10->20->30->40->50->60        for (i = 60; i >= 10; i -= 10)            push(i);          document.write("Given list<br/>");        printList();          rotate(4);          document.write("Rotated Linked List<br/>");        printList();  // This code is contributed by todaysgaurav  </script>
Output: 
Given linked list
10  20  30  40  50  60
Rotated Linked list
50  60  10  20  30  40
Time Complexity: O(n) where n is the number of nodes in Linked List. The code traverses the linked list only once.
Auxiliary Space : O(1)
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above. 
Method-2:To rotate a linked list by k, we can first make the linked list circular and then moving k-1 steps forward from head node, making (k-1)th node’s next to null and make kth node as head.
C++
Java
Python3
C#
Javascript
// C++ program to rotate// a linked list counter clock wise  #include <bits/stdc++.h>using namespace std;  /* Link list node */class Node {public:    int data;    Node* next;};  // This function rotates a linked list// counter-clockwise and updates the// head. The function assumes that k is// smaller than size of linked list.void rotate(Node** head_ref, int k){    if (k == 0)        return;      // Let us understand the below    // code for example k = 4 and    // list = 10->20->30->40->50->60.    Node* current = *head_ref;      // Traverse till the end.    while (current->next != NULL)        current = current->next;      current->next = *head_ref;    current = *head_ref;      // traverse the linked list to k-1 position which    // will be last element for rotated array.    for (int i = 0; i < k - 1; i++)        current = current->next;      // update the head_ref and last element pointer to NULL    *head_ref = current->next;    current->next = NULL;}  /* UTILITY FUNCTIONS *//* 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;}  /* Function to print linked list */void printList(Node* node){    while (node != NULL) {        cout << node->data << " ";        node = node->next;    }}  /* Driver code*/int main(void){    /* Start with the empty list */    Node* head = NULL;      // create a list 10->20->30->40->50->60    for (int i = 60; i > 0; i -= 10)        push(&head, i);      cout << "Given linked list \n";    printList(head);    rotate(&head, 4);      cout << "\nRotated Linked list \n";    printList(head);      return (0);}  // This code is contributed by pkurada
// Java program to rotate// a linked list counter clock wiseimport java.util.*;  class GFG{  /* Link list node */static class Node {      int data;    Node next;};static  Node head = null;    // This function rotates a linked list// counter-clockwise and updates the// head. The function assumes that k is// smaller than size of linked list.static void rotate( int k){    if (k == 0)        return;      // Let us understand the below    // code for example k = 4 and    // list = 10.20.30.40.50.60.    Node current = head;      // Traverse till the end.    while (current.next != null)        current = current.next;      current.next = head;    current = head;      // traverse the linked list to k-1 position which    // will be last element for rotated array.    for (int i = 0; i < k - 1; i++)        current = current.next;      // update the head_ref and last element pointer to null    head = current.next;    current.next = null;}  /* UTILITY FUNCTIONS *//* Function to push a node */static void push(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;      /* move the head to point to the new node */    head = new_node;}  /* Function to print linked list */static void printList(Node node){    while (node != null)    {        System.out.print(node.data + " ");        node = node.next;    }}  /* Driver code*/public static void  main(String[] args){    /* Start with the empty list */           // create a list 10.20.30.40.50.60    for (int i = 60; i > 0; i -= 10)        push( i);      System.out.print("Given linked list \n");    printList(head);    rotate( 4);      System.out.print("\nRotated Linked list \n");    printList(head);}}    // This code IS contributed by gauravrajput1 
# Python3 program to rotate# a linked list counter clock wise   # Link list node class Node:          def __init__(self):                  self.data = 0        self.next = None  # This function rotates a linked list# counter-clockwise and updates the# head. The function assumes that k is# smaller than size of linked list.def rotate(head_ref, k):      if (k == 0):        return       # Let us understand the below    # code for example k = 4 and    # list = 10.20.30.40.50.60.    current = head_ref       # Traverse till the end.    while (current.next != None):        current = current.next       current.next = head_ref    current = head_ref          # Traverse the linked list to k-1     # position which will be last element    # for rotated array.    for i in range(k - 1):        current = current.next       # Update the head_ref and last     # element pointer to None    head_ref = current.next    current.next = None    return head_ref   # UTILITY FUNCTIONS # Function to push a node def push(head_ref, new_data):      # Allocate node     new_node = 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      # Function to print linked list def printList(node):      while (node != None):        print(node.data, end = ' ')        node = node.next  # Driver codeif __name__=='__main__':          # Start with the empty list     head = None       # Create a list 10.20.30.40.50.60    for i in range(60, 0, -10):        head = push(head, i)       print("Given linked list ")    printList(head)    head = rotate(head, 4)       print("\nRotated Linked list ")    printList(head)  # This code is contributed by rutvik_56
// C# program to rotate// a linked list counter clock wiseusing System;  class GFG{  /* Link list node */public class Node {      public int data;    public Node next;};static  Node head = null;    // This function rotates a linked list// counter-clockwise and updates the// head. The function assumes that k is// smaller than size of linked list.static void rotate( int k){    if (k == 0)        return;      // Let us understand the below    // code for example k = 4 and    // list = 10.20.30.40.50.60.    Node current = head;      // Traverse till the end.    while (current.next != null)        current = current.next;      current.next = head;    current = head;      // traverse the linked list to k-1 position which    // will be last element for rotated array.    for (int i = 0; i < k - 1; i++)        current = current.next;      // update the head_ref and last element pointer to null    head = current.next;    current.next = null;}  /* UTILITY FUNCTIONS *//* Function to push a node */static void push(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;      /* move the head to point to the new node */    head = new_node;}  /* Function to print linked list */static void printList(Node node){    while (node != null)    {        Console.Write(node.data + " ");        node = node.next;    }}  /* Driver code*/public static void  Main(String[] args){    /* Start with the empty list */           // create a list 10.20.30.40.50.60    for (int i = 60; i > 0; i -= 10)        push( i);      Console.Write("Given linked list \n");    printList(head);    rotate( 4);      Console.Write("\nRotated Linked list \n");    printList(head);}}  // This code contributed by shikhasingrajput
<script>  // Javascript program to rotate// a linked list counter clock wise      /* Link list node */class Node {    constructor() {        this.data = 0;        this.next = null;    }}    var head = null;      // This function rotates a linked list    // counter-clockwise and updates the    // head. The function assumes that k is    // smaller than size of linked list.    function rotate(k) {        if (k == 0)            return;          // Let us understand the below        // code for example k = 4 and        // list = 10.20.30.40.50.60.        var current = head;          // Traverse till the end.        while (current.next != null)            current = current.next;          current.next = head;        current = head;          // traverse the linked list        // to k-1 position which        // will be last element for rotated array.        for (i = 0; i < k - 1; i++)            current = current.next;          // update the head_ref and last         // element pointer to null        head = current.next;        current.next = null;    }      /* UTILITY FUNCTIONS */    /* Function to push a node */    function push(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;          /* move the head to point to the new node */        head = new_node;    }      /* Function to print linked list */    function printList( node) {        while (node != null) {            document.write(node.data + " ");            node = node.next;        }    }      /* Driver code */              /* Start with the empty list */          // create a list 10.20.30.40.50.60        for (i = 60; i > 0; i -= 10)            push(i);          document.write("Given linked list <br/>");        printList(head);        rotate(4);          document.write("<br/>Rotated Linked list <br/>");        printList(head);  // This code contributed by aashish1995  </script>
Given linked list 
10 20 30 40 50 60 
Rotated Linked list 
50 60 10 20 30 40
 
Time Complexity: O(n) where n is the number of nodes in Linked List.
Auxiliary Space : O(1)
Add 1 to a number represented as linked list | GeeksforGeeks - YouTubeGeeksforGeeks529K subscribersAdd 1 to a number represented as linked list | GeeksforGeeksWatch laterShareCopy linkInfoShoppingTap to unmuteIf playback doesn't begin shortly, try restarting your device.More videosMore videosYou're signed outVideos you watch may be added to the TV's watch history and influence TV recommendations. To avoid this, cancel and sign in to YouTube on your computer.CancelConfirmSwitch cameraShareInclude playlistAn error occurred while retrieving sharing information. Please try again later.Watch on0:000:000:00 / 14:09•Live•<div class="player-unavailable"><h1 class="message">An error occurred.</h1><div class="submessage"><a href="https://www.youtube.com/watch?v=utc8bwTDjLk" target="_blank">Try watching this video on www.youtube.com</a>, or enable JavaScript if it is disabled in your browser.</div></div>
princiraj1992
rathbhupendra
nidhi_biet
pkurada
shrayansh95
GauravRajput1
shikhasingrajput
rutvik_56
aashish1995
todaysgaurav
skc161931
simranarora5sos
surinderdawra388
codewithmini
vijayalakshmivenkataraman
Accolite
MakeMyTrip
rotation
Linked List
Accolite
MakeMyTrip
Linked List
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Stack Data Structure (Introduction and Program)
LinkedList in Java
Introduction to Data Structures
What is Data Structure: Types, Classifications and Applications
Implementing a Linked List in Java using Class
Add two numbers represented by linked lists | Set 1
Detect and Remove Loop in a Linked List
Queue - Linked List Implementation
Function to check if a singly linked list is palindrome
Implement a stack using singly linked list