Rotate Doubly linked list by N nodes

Read

Discuss

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)

Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!

Last Updated : 11 Jan, 2023