Clockwise rotation of Doubly Linked List by N places

Given a doubly-linked list and an integer N, the task is to rotate the linked list clockwise by N nodes.

Examples:

Input: N = 2

Output:



Approach: To rotate the Doubly linked list first check whether the given N is greater than the length of the list or not. If N is greater than the size of the list then deduce it in the range of linked list size by taking modulo with the length of the list. After that subtract the value of N from the length of the list. Now the problem reduces to the counter-clockwise rotation of a doubly-linked list by N places.

  • Change the next of the last node to point the Head node.
  • Change the prev of the Head node to point the last node.
  • Change the value of the Head_ref to be the next of the Nth node.
  • Change the value of next of the Nth Node to be NULL.
  • Finally make the prev of Head node to point to NULL.

Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to rotate a Doubly linked
// list clock wise by N times
#include <bits/stdc++.h>
using namespace std;
  
/* Link list node */
struct Node {
    char data;
    struct Node* prev;
    struct Node* next;
};
  
// Utility function to find the size of
// Doubly Linked List
int size(struct Node* head_ref)
{
    struct Node* curr = head_ref;
    int sz = 0;
    while (curr != NULL) {
        curr = curr->next;
        sz++;
    }
    return sz;
}
  
/* Function to print linked list */
void printList(struct Node* node)
{
    while (node->next != NULL) {
        cout << node->data << " "
             << "<=>"
             << " ";
        node = node->next;
    }
    cout << node->data;
}
  
// Function to insert a node at the
// beginning of the Doubly Linked List
void push(struct Node** head_ref, int new_data)
{
    struct Node* new_node = new Node;
    new_node->data = new_data;
    new_node->prev = NULL;
    new_node->next = (*head_ref);
    if ((*head_ref) != NULL)
        (*head_ref)->prev = new_node;
    *head_ref = new_node;
}
  
// Function to rotate a doubly linked
// list clockwise and update the head
void rotate(struct Node** head_ref, int N, int sz)
{
  
    /* If N is greater than the size of Doubly
    Linked List, we have to deduce it in the range 
    of Doubly linked list size by taking modulo with the 
    length of the list.*/
    N = N % sz;
  
    /* We will update N by subtracting it's value length of 
    the list. After this the question will reduce to
    counter clockwise rotation of linked list to N places*/
    N = sz - N;
  
    if (N == 0)
        return;
  
    struct Node* current = *head_ref;
  
    // current will either point to Nth
    // or NULL after this loop. Current
    // will point to node 'b' in the
    // above example
    int count = 1;
    while (count < N && current != NULL) {
        current = current->next;
        count++;
    }
  
    // If current is NULL, N 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 Nth node. Store
    // it in a variable. NthNode points to
    // node 'b' in the above example
    struct Node* NthNode = current;
  
    // current will point to last node
    // after this loop current will point
    // to node 'e' in the above example
    while (current->next != NULL)
        current = current->next;
  
    // Change next of last node to previous
    // head. Next of 'e' is now changed to
    // node 'a'
    current->next = *head_ref;
  
    // Change prev of Head node to current
    // Prev of 'a' is now changed to node 'e'
    (*head_ref)->prev = current;
  
    // Change head to (N+1)th node
    // head is now changed to node 'c'
    *head_ref = NthNode->next;
  
    // Change prev of New Head node to NULL
    // Because Prev of Head Node in Doubly
    // linked list is NULL
    (*head_ref)->prev = NULL;
  
    // Change next of Nth node to NULL
    // next of 'b' is now NULL
    NthNode->next = NULL;
}
  
// Driver code
int main(void)
{
    /* Start with the empty list */
    struct Node* head = NULL;
  
    /* Create the doubly linked 
    list a<->b<->c<->d<->e */
    push(&head, 'e');
    push(&head, 'd');
    push(&head, 'c');
    push(&head, 'b');
    push(&head, 'a');
  
    int N = 2;
  
    // Length of the list
    int sz = size(head);
  
    cout << "Given Doubly linked list \n";
    printList(head);
    rotate(&head, N, sz);
  
    cout << "\nRotated Linked list clockwise \n";
    printList(head);
  
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to rotate a Doubly linked
// list clock wise by N times
class GFG
{
  
/* Link list node */
static class Node 
{
    char data;
    Node prev;
    Node next;
};
  
// Utility function to find the size of
// Doubly Linked List
static int size(Node head_ref)
{
    Node curr = head_ref;
    int sz = 0;
    while (curr != null)
    {
        curr = curr.next;
        sz++;
    }
    return sz;
}
  
/* Function to print linked list */
static void printList(Node node)
{
    while (node.next != null
    {
        System.out.print(
        node.data + " " + "<=>" + " ");
        node = node.next;
    }
    System.out.print(node.data);
}
  
// Function to insert a node at the
// beginning of the Doubly Linked List
static Node push(Node head_ref,
                 char new_data)
{
    Node new_node = new Node();
    new_node.data = new_data;
    new_node.prev = null;
    new_node.next = head_ref;
    if (head_ref != null)
        head_ref.prev = new_node;
    head_ref = new_node;
    return head_ref;
}
  
// Function to rotate a doubly linked
// list clockwise and update the head
static Node rotate(Node head_ref, 
                   int N, int sz)
{
  
    /* If N is greater than the size of 
    Doubly Linked List, we have to deduce it
    in the range of Doubly linked list size 
    by taking modulo with the length of the list.*/
    N = N % sz;
  
    /* We will update N by subtracting 
    it's value length of the list. 
    After this the question will 
    reduce to counter clockwise rotation 
    of linked list to N places*/
    N = sz - N;
  
    if (N == 0)
        return null;
  
    Node current = head_ref;
  
    // current will either point to Nth
    // or null after this loop. Current
    // will point to node 'b' in the
    // above example
    int count = 1;
    while (count < N && current != null
    {
        current = current.next;
        count++;
    }
  
    // If current is null, N is greater
    // than or equal to count of nodes
    // in linked list
    // Don't change the list in this case
    if (current == null)
        return null;
  
    // current points to Nth node. Store
    // it in a variable. NthNode points to
    // node 'b' in the above example
    Node NthNode = current;
  
    // current will point to last node
    // after this loop current will point
    // to node 'e' in the above example
    while (current.next != null)
        current = current.next;
  
    // Change next of last node to previous
    // head. Next of 'e' is now changed to
    // node 'a'
    current.next = head_ref;
  
    // Change prev of Head node to current
    // Prev of 'a' is now changed to node 'e'
    head_ref.prev = current;
  
    // Change head to (N+1)th node
    // head is now changed to node 'c'
    head_ref = NthNode.next;
  
    // Change prev of New Head node to null
    // Because Prev of Head Node in Doubly
    // linked list is null
    head_ref.prev = null;
  
    // Change next of Nth node to null
    // next of 'b' is now null
    NthNode.next = null;
    return head_ref;
}
  
// Driver code
public static void main(String []args) 
{
    /* Start with the empty list */
    Node head = null;
  
    /* Create the doubly linked 
    list a<->b<->c<->d<->e */
    head = push(head, 'e');
    head = push(head, 'd');
    head = push(head, 'c');
    head = push(head, 'b');
    head = push(head, 'a');
  
    int N = 2;
  
    // Length of the list
    int sz = size(head);
  
    System.out.println("Given Doubly linked list ");
    printList(head);
    head = rotate(head, N, sz);
  
    System.out.println("\nRotated Linked list clockwise ");
    printList(head);
}
}
  
// This code is contributed by 29AjayKumar

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Node of a doubly linked list 
class Node: 
    def __init__(self, next = None
                    prev = None, data = None): 
        self.next = next # reference to next node in DLL 
        self.prev = prev # reference to previous node in DLL 
        self.data = data 
  
# Function to insert a node at the
# beginning of the Doubly Linked List
def push(head, new_data): 
  
    new_node = Node(data = new_data) 
  
    new_node.next = head 
    new_node.prev = None
  
    if head is not None
        head.prev = new_node 
  
    head = new_node 
    return head 
  
# Utility function to find the size of
# Doubly Linked List
def size(head):
    node = head
    sz = 0
    while(node is not None):
        sz+= 1
        node = node.next
    return sz
  
# Function to print linked list
def printList(head): 
  
    node = head 
  
    print("Given linked list"
    while(node is not None): 
        print(node.data, end = " "), 
        last = node 
        node = node.next
  
# Function to rotate a doubly linked
# list clockwise and update the head
def rotate(start, N): 
    if N == 0
        return
  
    # Let us understand the below code 
    # for example N = 2 and 
    # list = a <-> b <-> c <-> d <-> e. 
    current = start 
  
    # current will either point to Nth 
    # or None after this loop. Current 
    # will point to node 'b' in the 
    # above example 
    count = 1
    while count < N and current != None
        current = current.next
        count += 1
  
    # If current is None, N is greater 
    # than or equal to count of nodes 
    # in linked list. Don't change the 
    # list in this case 
    if current == None
        return
  
    # current points to Nth node. Store 
    # it in a variable. NthNode points to 
    # node 'b' in the above example 
    NthNode = current 
  
    # current will point to last node 
    # after this loop current will point 
    # to node 'e' in the above example 
    while current.next != None
        current = current.next
  
    # Change next of last node to previous 
    # head. Next of 'e' is now changed to 
    # node 'a' 
    current.next = start 
  
    # Change prev of Head node to current 
    # Prev of 'a' is now changed to node 'e' 
    start.prev = current 
  
    # Change head to (N + 1)th node 
    # head is now changed to node 'c' 
    start = NthNode.next
  
    # Change prev of New Head node to None 
    # Because Prev of Head Node in Doubly 
    # linked list is None 
    start.prev = None
  
    # change next of Nth node to None 
    # next of 'b' is now None 
    NthNode.next = None
  
    return start 
  
# Driver Code 
if __name__ == "__main__"
    head = None
  
    head = push(head, 'e'
    head = push(head, 'd'
    head = push(head, 'c'
    head = push(head, 'b'
    head = push(head, 'a'
  
    printList(head) 
    print("\n"
      
    N = 2
  
    # Length of the list
    sz = size(head)
  
    # If N is greater than the size of Doubly
    # Linked List, we have to deduce it in the range 
    # of Doubly linked list size by taking modulo with the 
    # length of the list.
    N = N % sz;
      
    # We will update N by subtracting it's value length of 
    # the list. After this the question will reduce to
    # counter-clockwise rotation of linked list to N places
    N = sz-N;
      
    head = rotate(head, N) 
  
    printList(head) 

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program to rotate a Doubly linked
// list clock wise by N times
using System;
      
class GFG
{
  
/* Link list node */
public class Node 
{
    public char data;
    public Node prev;
    public Node next;
};
  
// Utility function to find the size of
// Doubly Linked List
static int size(Node head_ref)
{
    Node curr = head_ref;
    int sz = 0;
    while (curr != null)
    {
        curr = curr.next;
        sz++;
    }
    return sz;
}
  
/* Function to print linked list */
static void printList(Node node)
{
    while (node.next != null
    {
        Console.Write(
        node.data + " " + "<=>" + " ");
        node = node.next;
    }
    Console.Write(node.data);
}
  
// Function to insert a node at the
// beginning of the Doubly Linked List
static Node push(Node head_ref,
                 char new_data)
{
    Node new_node = new Node();
    new_node.data = new_data;
    new_node.prev = null;
    new_node.next = head_ref;
    if (head_ref != null)
        head_ref.prev = new_node;
    head_ref = new_node;
    return head_ref;
}
  
// Function to rotate a doubly linked
// list clockwise and update the head
static Node rotate(Node head_ref, 
                   int N, int sz)
{
  
    /* If N is greater than the size of 
    Doubly Linked List, we have to deduce it
    in the range of Doubly linked list size 
    by taking modulo with the length of the list.*/
    N = N % sz;
  
    /* We will update N by subtracting 
    it's value length of the list. 
    After this the question will 
    reduce to counter clockwise rotation 
    of linked list to N places*/
    N = sz - N;
  
    if (N == 0)
        return null;
  
    Node current = head_ref;
  
    // current will either point to Nth
    // or null after this loop. Current
    // will point to node 'b' in the
    // above example
    int count = 1;
    while (count < N && current != null
    {
        current = current.next;
        count++;
    }
  
    // If current is null, N is greater
    // than or equal to count of nodes
    // in linked list
    // Don't change the list in this case
    if (current == null)
        return null;
  
    // current points to Nth node. Store
    // it in a variable. NthNode points to
    // node 'b' in the above example
    Node NthNode = current;
  
    // current will point to last node
    // after this loop current will point
    // to node 'e' in the above example
    while (current.next != null)
        current = current.next;
  
    // Change next of last node to previous
    // head. Next of 'e' is now changed to
    // node 'a'
    current.next = head_ref;
  
    // Change prev of Head node to current
    // Prev of 'a' is now changed to node 'e'
    head_ref.prev = current;
  
    // Change head to (N+1)th node
    // head is now changed to node 'c'
    head_ref = NthNode.next;
  
    // Change prev of New Head node to null
    // Because Prev of Head Node in Doubly
    // linked list is null
    head_ref.prev = null;
  
    // Change next of Nth node to null
    // next of 'b' is now null
    NthNode.next = null;
    return head_ref;
}
  
// Driver code
public static void Main(String []args) 
{
    /* Start with the empty list */
    Node head = null;
  
    /* Create the doubly linked 
    list a<->b<->c<->d<->e */
    head = push(head, 'e');
    head = push(head, 'd');
    head = push(head, 'c');
    head = push(head, 'b');
    head = push(head, 'a');
  
    int N = 2;
  
    // Length of the list
    int sz = size(head);
  
    Console.WriteLine("Given Doubly linked list ");
    printList(head);
    head = rotate(head, N, sz);
  
    Console.WriteLine("\nRotated Linked list clockwise ");
    printList(head);
}
}
  
// This code is contributed by Rajput-Ji

chevron_right


Output:

Given Doubly linked list 
a <=> b <=> c <=> d <=> e
Rotated Linked list clockwise 
d <=> e <=> a <=> b <=> c

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 : 29AjayKumar, Rajput-Ji



Article Tags :
Practice Tags :


1


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.