Rotate Doubly linked list by N nodes

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)