Clockwise rotation of Linked List

Given a singly 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 -> NULL



Input: 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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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 pointer
Node* 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)
        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 code
int 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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java implementation of the approach
class 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 pointer
static 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)
        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 code
public 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# implementation of the approach
using 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 pointer
static 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)
        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 code
public 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

chevron_right


Output:

4 -> 5 -> 1 -> 2 -> 3 -> NULL

Time Complexity: O(n) where n is the number of nodes in Linked List.



My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.



Improved By : andrew1234, princiraj1992