Open In App
Related Articles

Rotate Doubly linked list by N nodes

Improve
Improve
Improve
Like Article
Like
Save Article
Save
Report issue
Report

Given a doubly-linked list, rotate the linked list counter-clockwise by N nodes. Here N is a given positive integer and is smaller than the count of nodes in linked list. 


N = 2
Rotated List: 

Examples:  

Input : a  b  c  d  e   N = 2
Output : c  d  e  a  b 

Input : a  b  c  d  e  f  g  h   N = 4
Output : e  f  g  h  a  b  c  d 


Asked in Amazon 

Solution 1:

C++

#include<iostream>
using namespace std;
  
class Node
{
    public:
        char data;
        Node* next;
        Node* pre;
    Node(int data)
    {
        this->data=data;
        pre=NULL;
        next=NULL;
    }
};
  
void insertAtHead(Node* &head, int data)
{
    Node* n = new Node(data);
    if(head==NULL)
    {
        head=n;
        return;
    }
    n->next=head;
    head->pre=n;
    head=n;
    return;
}
void insertAtTail(Node* &head, int data)
{
    if(head==NULL)
    {
        insertAtHead(head,data);
        return;
    }
    Node* temp=head;
    while(temp->next!=NULL)
    {
        temp=temp->next;
    }
    Node* n=new Node(data);
    temp->next=n;
    n->pre=temp;
    return;
}
void display(Node* head)
{
    while(head!=NULL)
    {
        cout << head->data << " ";
        head=head->next;
    }
}
  
void rotateByN(Node* &head, int pos)
{
    // return without any changes if position is 0.
    if(pos==0) return;
  
    // Finding last node.
    Node* temp=head;
    while(temp->next!=NULL)
    {
        temp=temp->next;
    }
    // making the list circular.
    temp->next=head;
    head->pre=temp;
  
    // move head and temp by the given position.
    int count=1;
    while(count<=pos)
    {
        head=head->next;
        temp=temp->next;
        count++;
    }
  
    // now again make list un-circular.
    temp->next=NULL;
    head->pre=NULL;
}
int main()
{
    Node* head=NULL;
    insertAtTail(head,'a');
    insertAtTail(head,'b');
    insertAtTail(head,'c');
    insertAtTail(head,'d');
    insertAtTail(head,'e');
  
    int n=2;
    cout << "Given linked list \n";
    display(head);
    rotateByN(head,n);
    cout << "\nRotated Linked list \n";
    display(head);
    cout << "\n\n";
  
    return 0;
}

                    

Java

// Java program to rotate a Doubly linked
// list counter clock wise by N times
import java.io.*;
import java.util.*;
  
class GfG {
  
    /* Link list node */
    static class Node {
        char data;
        Node prev;
        Node next;
    }
    static Node head = null;
  
    // This function rotates a doubly linked
    // list counter-clockwise and updates the
    // head. The function assumes that N is
    // smallerthan size of linked list. It
    // doesn't modify the list if N is greater
    // than or equal to size
    static void rotate(int N)
    {
        if (N == 0)
            return;
  
        // Let us understand the below code
        // for example N = 2 and
        // list = a <-> b <-> c <-> d <-> e.
        Node current = head;
  
        // 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
        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;
  
        // Change prev of Head node to current
        // Prev of 'a' is now changed to node 'e'
        (head).prev = current;
  
        // Change head to (N+1)th node
        // head is now changed to node 'c'
        head = NthNode.next;
  
        // Change prev of New Head node to NULL
        // Because Prev of Head Node in Doubly
        // linked list is NULL
        (head).prev = null;
  
        // change next of Nth node to NULL
        // next of 'b' is now NULL
        NthNode.next = null;
    }
  
    // Function to insert a node at the
    // beginning of the Doubly Linked List
    static void push(char new_data)
    {
        Node new_node = new Node();
        new_node.data = new_data;
        new_node.prev = null;
        new_node.next = (head);
        if ((head) != null)
            (head).prev = new_node;
        head = new_node;
    }
  
    /* Function to print linked list */
    static void printList(Node node)
    {
        while (node != null && node.next != null) {
            System.out.print(node.data + " ");
            node = node.next;
        }
        if (node != null)
            System.out.print(node.data);
    }
  
    // Driver's Code
    public static void main(String[] args)
    {
        /* Start with the empty list */
        // Node head = null;
  
        /* Let us create the doubly
        linked list a<->b<->c<->d<->e */
        push('e');
        push('d');
        push('c');
        push('b');
        push('a');
  
        int N = 2;
  
        System.out.println("Given linked list ");
        printList(head);
        rotate(N);
        System.out.println();
        System.out.println("Rotated Linked list ");
        printList(head);
    }
}
  
// This code is contributed by Prerna Saini

                    

Python3

# 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 
  
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
  
def printList(head):
  
    node = head
  
    print("Given linked list")
    while(node is not None): 
        print(node.data, end = " "), 
        last = node 
        node = node.next
      
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
    head = rotate(head, N)
  
    printList(head)
  
# This code is contributed by vinayak sharma

                    

C#

// C# program to rotate a Doubly linked 
// list counter clock wise by N times 
using System;
  
class GfG 
  
/* Link list node */
public class Node 
    public char data; 
    public Node prev; 
    public Node next; 
static Node head = null
  
// This function rotates a doubly linked 
// list counter-clockwise and updates the 
// head. The function assumes that N is 
// smallerthan size of linked list. It 
// doesn't modify the list if N is greater 
// than or equal to size 
static void rotate( int N) 
    if (N == 0) 
        return
  
    // Let us understand the below code 
    // for example N = 2 and 
    // list = a <-> b <-> c <-> d <-> e. 
    Node current = head; 
  
    // 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 
    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; 
  
    // Change prev of Head node to current 
    // Prev of 'a' is now changed to node 'e' 
    (head).prev = current; 
  
    // Change head to (N+1)th node 
    // head is now changed to node 'c' 
    head = NthNode.next; 
  
    // Change prev of New Head node to NULL 
    // Because Prev of Head Node in Doubly 
    // linked list is NULL 
    (head).prev = null
  
    // change next of Nth node to NULL 
    // next of 'b' is now NULL 
    NthNode.next = null
  
// Function to insert a node at the 
// beginning of the Doubly Linked List 
static void push(char new_data) 
    Node new_node = new Node(); 
    new_node.data = new_data; 
    new_node.prev = null
    new_node.next = (head); 
    if ((head) != null
        (head).prev = new_node; 
    head = new_node; 
  
/* Function to print linked list */
static void printList(Node node) 
    while (node != null && node.next != null
    
        Console.Write(node.data + " "); 
        node = node.next; 
    
    if(node != null
    Console.Write(node.data); 
  
// Driver Code 
public static void Main(String []args) 
    /* Start with the empty list */
    // Node head = null; 
  
    /* Let us create the doubly 
    linked list a<->b<->c<->d<->e */
    push( 'e'); 
    push( 'd'); 
    push( 'c'); 
    push( 'b'); 
    push( 'a'); 
  
    int N = 2; 
  
    Console.WriteLine("Given linked list "); 
    printList(head); 
    rotate( N); 
    Console.WriteLine(); 
    Console.WriteLine("Rotated Linked list "); 
    printList(head); 
  
// This code is contributed by Arnab Kundu

                    

Javascript

<script>
// javascript program to rotate a Doubly linked 
// list counter clock wise by N times 
  
    /* Link list node */
     class Node {
            constructor() {
                this.data = 0;
                this.prev = null;
                this.next = null;
            }
        }
    var head = null;
  
    // This function rotates a doubly linked
    // list counter-clockwise and updates the
    // head. The function assumes that N is
    // smallerthan size of linked list. It
    // doesn't modify the list if N is greater
    // than or equal to size
    function rotate(N) {
        if (N == 0)
            return;
  
        // Let us understand the below code
        // for example N = 2 and
        // list = a <-> b <-> c <-> d <-> e.
var current = head;
  
        // current will either point to Nth
        // or NULL after this loop. Current
        // will point to node 'b' in the
        // above example
        var 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
var 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;
  
        // Change prev of Head node to current
        // Prev of 'a' is now changed to node 'e'
        (head).prev = current;
  
        // Change head to (N+1)th node
        // head is now changed to node 'c'
        head = NthNode.next;
  
        // Change prev of New Head node to NULL
        // Because Prev of Head Node in Doubly
        // linked list is NULL
        (head).prev = null;
  
        // change next of Nth node to NULL
        // next of 'b' is now NULL
        NthNode.next = null;
    }
  
    // Function to insert a node at the
    // beginning of the Doubly Linked List
    function push( new_data) {
var new_node = new Node();
        new_node.data = new_data;
        new_node.prev = null;
        new_node.next = (head);
        if ((head) != null)
            (head).prev = new_node;
        head = new_node;
    }
  
    /* Function to print linked list */
    function printList(node) {
        while (node != null && node.next != null) {
            document.write(node.data + " ");
            node = node.next;
        }
        if (node != null)
            document.write(node.data);
    }
  
    // Driver's Code
      
        /* Start with the empty list */
        // Node head = null;
  
        /*
         * Let us create the doubly linked list a<->b<->c<->d<->e
         */
        push('e');
        push('d');
        push('c');
        push('b');
        push('a');
  
        var N = 2;
  
        document.write("Given linked list <br/>");
        printList(head);
        rotate(N);
        document.write();
        document.write("<br/>Rotated Linked list <br/>");
        printList(head);
  
// This code contributed by aashish1995
</script>

                    

Output
Before Rotation : 
a-->b-->c-->d-->e-->NULL

After Rotation : 
c-->d-->e-->a-->b-->NULL

Time Complexity: O(N)
Space Complexity: O(1)

Solution 2: 

C++

#include<iostream>
using namespace std;
  
class Node
{
    public:
        char data;
        Node* next;
        Node* pre;
    Node(int data)
    {
        this->data=data;
        pre=NULL;
        next=NULL;
    }
};
  
void insertAtHead(Node* &head, int data)
{
    Node* n = new Node(data);
    if(head==NULL)
    {
        head=n;
        return;
    }
    n->next=head;
    head->pre=n;
    head=n;
    return;
}
void insertAtTail(Node* &head, int data)
{
    if(head==NULL)
    {
        insertAtHead(head,data);
        return;
    }
    Node* temp=head;
    while(temp->next!=NULL)
    {
        temp=temp->next;
    }
    Node* n=new Node(data);
    temp->next=n;
    n->pre=temp;
    return;
}
void display(Node* head)
{
    while(head!=NULL)
    {
        cout << head->data << "-->";
        head=head->next;
    }
    cout << "NULL\n";
}
  
void rotateByN(Node *&head, int pos)
{
    if (pos == 0)
        return;
  
    Node *curr = head;
  
    while (pos)
    {
        curr = curr->next;
        pos--;
    }
  
    Node *tail = curr->pre;
    Node *NewHead = curr;
    tail->next = NULL;
    curr->pre = NULL;
  
    while (curr->next != NULL)
    {
        curr = curr->next;
    }
      
    curr->next = head;
    head->pre = curr;
    head = NewHead;
}
   
int main()
{
    Node* head=NULL;
    insertAtTail(head,'a');
    insertAtTail(head,'b');
    insertAtTail(head,'c');
    insertAtTail(head,'d');
    insertAtTail(head,'e');
  
    int n=2;
    cout << "\nBefore Rotation : \n";
    display(head);
    rotateByN(head,n);
    cout << "\nAfter Rotation : \n";
    display(head);
    cout << "\n\n";
  
    return 0;
}

                    

Java

// Java code to rotate doubly linked list by N nodes.
import java.util.*;
import java.io.*;
  
class GFG {
  
    class Node {
        char data;
        Node next;
        Node pre;
        Node(char data)
        {
            this.data = data;
            pre = null;
            next = null;
        }
    }
  
    Node head = null;
  
    // Function to insert nodes at the start of the linked
    // list.
    public void insertAtHead(char data)
    {
        Node n = new Node(data);
        if (head == null) {
            head = n;
            return;
        }
        n.next = head;
        head.pre = n;
        head = n;
    }
  
    // Function to insert nodes at the tail of the linked
    // list.
    public void insertAtTail(char data)
    {
        if (head == null) {
            insertAtHead(data);
            return;
        }
        Node temp = head;
        while (temp.next != null) {
            temp = temp.next;
        }
        Node n = new Node(data);
        temp.next = n;
        n.pre = temp;
    }
  
    // Function to print the list.
    public void display()
    {
        Node curr = head;
        while (curr != null) {
            System.out.print(curr.data + "-->");
            curr = curr.next;
        }
        System.out.print("NULL\n\n");
    }
  
    // Function to rotate doubly linked list by N nodes.
    public void rotateByN(int pos)
    {
        if (pos == 0) {
            return;
        }
        Node curr = head;
        while (pos != 0) {
            curr = curr.next;
            pos--;
        }
        Node tail = curr.pre;
        Node NewHead = curr;
        tail.next = null;
        curr.pre = null;
        while (curr.next != null) {
            curr = curr.next;
        }
        curr.next = head;
        head.pre = curr;
        head = NewHead;
    }
  
    public static void main(String[] args)
    {
        GFG list = new GFG();
  
        list.insertAtTail('a');
        list.insertAtTail('b');
        list.insertAtTail('c');
        list.insertAtTail('d');
        list.insertAtTail('e');
  
        int n = 2;
        System.out.print("Before Rotation : \n");
        list.display();
        
        list.rotateByN(n);
        System.out.print("After Rotation : \n");
        list.display();
    }
}
  
// This code is contributed by lokesh (lokeshmvs21).

                    

Python3

# Python code to rotate doubly linked list by N nodes.
class Node:
    def __init__(self, data):
        self.data = data
        self.pre = None
        self.next = None
  
class GFG:
    def __init__(self):
        self.head = None
  
    # Function to insert nodes at the start of the linked list.
    def insertAtHead(self, data):
        n = Node(data)
        if self.head == None:
            self.head = n
            return
  
        n.next = self.head
        self.head.pre = n
        self.head = n
        return
  
    # Function to insert nodes at the tail of the linked list.
    def insertAtTail(self, data):
        if self.head == None:
            self.insertAtHead(data)
            return
        temp = self.head
        while temp.next != None:
            temp = temp.next
        n = Node(data)
        temp.next = n
        n.pre = temp
        return
        
    # Function to print the list.
    def display(self):
        temp = self.head
        while temp != None:
            print(temp.data, "-->", sep="", end="")
            temp = temp.next
        print("NULL")
  
    # Function to rotate doubly linked list by N nodes.
    def rotateByN(self, pos):
        if pos == 0:
            return
        curr = self.head
        while pos:
            curr = curr.next
            pos -= 1
        tail = curr.pre
        NewHead = curr
        tail.next = None
        curr.pre = None
  
        while curr.next != None:
            curr = curr.next
  
        curr.next = self.head
        self.head.pre = curr
        self.head = NewHead
  
  
# Driver Code
if __name__ == "__main__":
    list = GFG()
    list.insertAtTail('a')
    list.insertAtTail('b')
    list.insertAtTail('c')
    list.insertAtTail('d')
    list.insertAtTail('e')
  
    n = 2
    print("Before Rotation : ")
    list.display()
    list.rotateByN(n)
    print("\nAfter Rotation : ")
    list.display()
    print()
  
# This code is contributed by Tapesh(tapeshdua420)

                    

C#

// C# code to rotate doubly linked list by N nodes.
  
using System;
  
public class GFG {
  
    class Node {
        public char data;
        public Node next, pre;
        public Node(char data)
        {
            this.data = data;
            pre = null;
            next = null;
        }
    }
  
    Node head = null;
  
    // Function to insert nodes at the start of the linked
    // list.
    public void insertAtHead(char data)
    {
        Node n = new Node(data);
        if (head == null) {
            head = n;
            return;
        }
        n.next = head;
        head.pre = n;
        head = n;
    }
  
    // Function to insert nodes at the tail of the linked
    // list.
    public void insertAtTail(char data)
    {
        if (head == null) {
            insertAtHead(data);
            return;
        }
        Node temp = head;
        while (temp.next != null) {
            temp = temp.next;
        }
        Node n = new Node(data);
        temp.next = n;
        n.pre = temp;
    }
  
    // Function to print the list.
    public void display()
    {
        Node curr = head;
        while (curr != null) {
            Console.Write(curr.data + "-->");
            curr = curr.next;
        }
        Console.Write("NULL\n\n");
    }
  
    // Function to rotate doubly linked list by N nodes.
    public void rotateByN(int pos)
    {
        if (pos == 0) {
            return;
        }
        Node curr = head;
        while (pos != 0) {
            curr = curr.next;
            pos--;
        }
        Node tail = curr.pre;
        Node NewHead = curr;
        tail.next = null;
        curr.pre = null;
        while (curr.next != null) {
            curr = curr.next;
        }
        curr.next = head;
        head.pre = curr;
        head = NewHead;
    }
  
    static public void Main()
    {
  
        // Code
        GFG list = new GFG();
  
        list.insertAtTail('a');
        list.insertAtTail('b');
        list.insertAtTail('c');
        list.insertAtTail('d');
        list.insertAtTail('e');
  
        int n = 2;
        Console.Write("Before Rotation : \n");
        list.display();
  
        list.rotateByN(n);
        Console.Write("After Rotation : \n");
        list.display();
    }
}
  
// This code is contributed by lokesh(lokeshmvs21).

                    

Javascript

<script>
// Javascript code to Rotate Doubly linked list by N nodes
  
let head = null;
  
  
class Node {
    constructor(data) {
        this.data = data;
        this.pre = null;
        this.next = null;
    }
};
  
function insertAtHead(data) {
    let n = new Node(data);
    if (head == null) {
        head = n;
        return;
    }
    n.next = head;
    head.pre = n;
    head = n;
    return;
}
  
function insertAtTail(data) {
    if (head == null) {
        insertAtHead(data);
        return;
    }
    let temp = head;
    while (temp.next != null) {
        temp = temp.next;
    }
    let n = new Node(data);
    temp.next = n;
    n.pre = temp;
    return;
}
  
function display(head) {
    while (head != null) {
        document.write(head.data + "-->");
        head = head.next;
    }
    document.write("null<br>");
}
  
function rotateByN(pos) {
    if (pos == 0)
        return;
  
    let curr = head;
  
    while (pos) {
        curr = curr.next;
        pos--;
    }
  
    let tail = curr.pre;
    let NewHead = curr;
    tail.next = null;
    curr.pre = null;
  
    while (curr.next != null) {
        curr = curr.next;
    }
  
    curr.next = head;
    head.pre = curr;
    head = NewHead;
}
  
insertAtTail('a');
insertAtTail('b');
insertAtTail('c');
insertAtTail('d');
insertAtTail('e');
  
let n = 2;
document.write("<br>Before Rotation : <br>");
display(head);
rotateByN(head, n);
document.write("<br>After Rotation : <br>");
display(head);
document.write("<br><br>");
</script>

                    

Output
Before Rotation : 
a-->b-->c-->d-->e-->NULL

After Rotation : 
c-->d-->e-->a-->b-->NULL

Time Complexity: O(N)
Space Complexity: O(1)



Last Updated : 11 Jan, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads