A doubly linked list has pointers with each node

/* Node of a doubly linked list */ class Node { public: int data; Node* next; // Pointer to next node in DLL Node* prev; // Pointer to previous node in DLL }; // This code is contributed by shivanisinghss2110

/* Node of a doubly linked list */ struct Node { int data; struct Node* next; // Pointer to next node in DLL struct Node* prev; // Pointer to previous node in DLL };

// Class for Doubly Linked List public class DLL { Node head; // head of list /* Doubly Linked list Node*/ class Node { int data; Node prev; Node next; // Constructor to create a new node // next and prev is by default initialized as null Node[int d] { data = d; } } }

# 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

// Class for Doubly Linked List public class DLL { Node head; // head of list /* Doubly Linked list Node*/ public class Node { public int data; public Node prev; public Node next; // Constructor to create a new node // next and prev is by default initialized as null Node[int d] { data = d; } } } // This code contributed by gauravrajput1

// Class for Doubly Linked List var head; // head of list /* Doubly Linked list Node */ class Node { // Constructor to create a new node // next and prev is by default initialized as null constructor[val] { this.data = val; this.prev = null; this.next = null; } } // This code contributed by gauravrajput1

/* Given a reference [pointer to pointer] to the head of a list and an int, inserts a new node on the front of the list. */ void push[Node** head_ref, int new_data] { /* 1. allocate node */ Node* new_node = new Node[]; /* 2. put in the data */ new_node->data = new_data; /* 3. Make next of new node as head and previous as NULL */ new_node->next = [*head_ref]; new_node->prev = NULL; /* 4. change prev of head node to new node */ if [[*head_ref] != NULL] [*head_ref]->prev = new_node; /* 5. move the head to point to the new node */ [*head_ref] = new_node; } // This code is contributed by shivanisinghss2110

/* Given a reference [pointer to pointer] to the head of a list and an int, inserts a new node on the front of the list. */ void push[struct Node** head_ref, int new_data] { /* 1. allocate node */ struct Node* new_node = [struct Node*]malloc[sizeof[struct Node]]; /* 2. put in the data */ new_node->data = new_data; /* 3. Make next of new node as head and previous as NULL */ new_node->next = [*head_ref]; new_node->prev = NULL; /* 4. change prev of head node to new node */ if [[*head_ref] != NULL] [*head_ref]->prev = new_node; /* 5. move the head to point to the new node */ [*head_ref] = new_node; }

// Adding a node at the front of the list public void push[int new_data] { /* 1. allocate node * 2. put in the data */ Node new_Node = new Node[new_data]; /* 3. Make next of new node as head and previous as NULL */ new_Node.next = head; new_Node.prev = null; /* 4. change prev of head node to new node */ if [head != null] head.prev = new_Node; /* 5. move the head to point to the new node */ head = new_Node; }

# Adding a node at the front of the list def push[self, new_data]: # 1 & 2: Allocate the Node & Put in the data new_node = Node[data = new_data] # 3. Make next of new node as head and previous as NULL new_node.next = self.head new_node.prev = None # 4. change prev of head node to new node if self.head is not None: self.head.prev = new_node # 5. move the head to point to the new node self.head = new_node # This code is contributed by jatinreaper

// Adding a node at the front of the list public void push[int new_data] { /* 1. allocate node * 2. put in the data */ Node new_Node = new Node[new_data]; /* 3. Make next of new node as head and previous as NULL */ new_Node.next = head; new_Node.prev = null; /* 4. change prev of head node to new node */ if [head != null] head.prev = new_Node; /* 5. move the head to point to the new node */ head = new_Node; } // This code is contributed by aashish2995

// Adding a node at the front of the list function push[new_data] { /* 1. allocate node * 2. put in the data */ let new_Node = new Node[new_data]; /* 3. Make next of new node as head and previous as NULL */ new_Node.next = head; new_Node.prev = null; /* 4. change prev of head node to new node */ if [head != null] head.prev = new_Node; /* 5. move the head to point to the new node */ head = new_Node; } // This code is contributed by saurabh_jaiswal.

/* Given a node as prev_node, insert a new node after the given node */ void insertAfter[Node* prev_node, int new_data] { /*1. check if the given prev_node is NULL */ if [prev_node == NULL] { coutnext = prev_node->next; /* 5. Make the next of prev_node as new_node */ prev_node->next = new_node; /* 6. Make prev_node as previous of new_node */ new_node->prev = prev_node; /* 7. Change previous of new_node's next node */ if [new_node->next != NULL] new_node->next->prev = new_node; } // This code is contributed by shivanisinghss2110.

/* Given a node as prev_node, insert a new node after the given node */ void insertAfter[struct Node* prev_node, int new_data] { /*1. check if the given prev_node is NULL */ if [prev_node == NULL] { printf["the given previous node cannot be NULL"]; return; } /* 2. allocate new node */ struct Node* new_node = [struct Node*]malloc[sizeof[struct Node]]; /* 3. put in the data */ new_node->data = new_data; /* 4. Make next of new node as next of prev_node */ new_node->next = prev_node->next; /* 5. Make the next of prev_node as new_node */ prev_node->next = new_node; /* 6. Make prev_node as previous of new_node */ new_node->prev = prev_node; /* 7. Change previous of new_node's next node */ if [new_node->next != NULL] new_node->next->prev = new_node; }

/* Given a node as prev_node, insert a new node after the given node */ public void InsertAfter[Node prev_Node, int new_data] { /*1. check if the given prev_node is NULL */ if [prev_Node == null] { System.out.println["The given previous node cannot be NULL "]; return; } /* 2. allocate node * 3. put in the data */ Node new_node = new Node[new_data]; /* 4. Make next of new node as next of prev_node */ new_node.next = prev_Node.next; /* 5. Make the next of prev_node as new_node */ prev_Node.next = new_node; /* 6. Make prev_node as previous of new_node */ new_node.prev = prev_Node; /* 7. Change previous of new_node's next node */ if [new_node.next != null] new_node.next.prev = new_node; }

# Given a node as prev_node, insert # a new node after the given node def insertAfter[self, prev_node, new_data]: # 1. check if the given prev_node is NULL if prev_node is None: print["This node doesn't exist in DLL"] return #2. allocate node & 3. put in the data new_node = Node[data = new_data] # 4. Make next of new node as next of prev_node new_node.next = prev_node.next # 5. Make the next of prev_node as new_node prev_node.next = new_node # 6. Make prev_node as previous of new_node new_node.prev = prev_node # 7. Change previous of new_node's next node */ if new_node.next is not None: new_node.next.prev = new_node # This code is contributed by jatinreaper

/* Given a node as prev_node, insert a new node after the given node */ public void InsertAfter[Node prev_Node, int new_data] { /*1. check if the given prev_node is NULL */ if [prev_Node == null] { Console.WriteLine["The given previous node cannot be NULL "]; return; } /* 2. allocate node * 3. put in the data */ Node new_node = new Node[new_data]; /* 4. Make next of new node as next of prev_node */ new_node.next = prev_Node.next; /* 5. Make the next of prev_node as new_node */ prev_Node.next = new_node; /* 6. Make prev_node as previous of new_node */ new_node.prev = prev_Node; /* 7. Change previous of new_node's next node */ if [new_node.next != null] new_node.next.prev = new_node; } // This code is contributed by aashish2995

function InsertAfter[prev_Node,new_data] { /*1. check if the given prev_node is NULL */ if [prev_Node == null] { document.write["The given previous node cannot be NULL
"]; return; } /* 2. allocate node * 3. put in the data */ let new_node = new Node[new_data]; /* 4. Make next of new node as next of prev_node */ new_node.next = prev_Node.next; /* 5. Make the next of prev_node as new_node */ prev_Node.next = new_node; /* 6. Make prev_node as previous of new_node */ new_node.prev = prev_Node; /* 7. Change previous of new_node's next node */ if [new_node.next != null] new_node.next.prev = new_node; } // This code is contributed by unknown2108

/* Given a reference [pointer to pointer] to the head of a DLL and an int, appends a new node at the end */ void append[Node** head_ref, int new_data] { /* 1. allocate node */ Node* new_node = new Node[]; Node* last = *head_ref; /* used in step 5*/ /* 2. put in the data */ new_node->data = new_data; /* 3. This new node is going to be the last node, so make next of it as NULL*/ new_node->next = NULL; /* 4. If the Linked List is empty, then make the new node as head */ if [*head_ref == NULL] { new_node->prev = NULL; *head_ref = new_node; return; } /* 5. Else traverse till the last node */ while [last->next != NULL] last = last->next; /* 6. Change the next of last node */ last->next = new_node; /* 7. Make last node as previous of new node */ new_node->prev = last; return; } // This code is contributed by shivanisinghss2110

/* Given a reference [pointer to pointer] to the head of a DLL and an int, appends a new node at the end */ void append[struct Node** head_ref, int new_data] { /* 1. allocate node */ struct Node* new_node = [struct Node*]malloc[sizeof[struct Node]]; struct Node* last = *head_ref; /* used in step 5*/ /* 2. put in the data */ new_node->data = new_data; /* 3. This new node is going to be the last node, so make next of it as NULL*/ new_node->next = NULL; /* 4. If the Linked List is empty, then make the new node as head */ if [*head_ref == NULL] { new_node->prev = NULL; *head_ref = new_node; return; } /* 5. Else traverse till the last node */ while [last->next != NULL] last = last->next; /* 6. Change the next of last node */ last->next = new_node; /* 7. Make last node as previous of new node */ new_node->prev = last; return; }

// Add a node at the end of the list void append[int new_data] { /* 1. allocate node * 2. put in the data */ Node new_node = new Node[new_data]; Node last = head; /* used in step 5*/ /* 3. This new node is going to be the last node, so * make next of it as NULL*/ new_node.next = null; /* 4. If the Linked List is empty, then make the new * node as head */ if [head == null] { new_node.prev = null; head = new_node; return; } /* 5. Else traverse till the last node */ while [last.next != null] last = last.next; /* 6. Change the next of last node */ last.next = new_node; /* 7. Make last node as previous of new node */ new_node.prev = last; }

# Add a node at the end of the DLL def append[self, new_data]: # 1. allocate node 2. put in the data new_node = Node[data = new_data] last = self.head # 3. This new node is going to be the # last node, so make next of it as NULL new_node.next = None # 4. If the Linked List is empty, then # make the new node as head if self.head is None: new_node.prev = None self.head = new_node return # 5. Else traverse till the last node while [last.next is not None]: last = last.next # 6. Change the next of last node last.next = new_node # 7. Make last node as previous of new node */ new_node.prev = last # This code is contributed by jatinreaper

// Add a node at the end of the list void append[int new_data] { /* 1. allocate node * 2. put in the data */ Node new_node = new Node[new_data]; Node last = head; /* used in step 5*/ /* 3. This new node is going to be the last node, so * make next of it as NULL*/ new_node.next = null; /* 4. If the Linked List is empty, then make the new * node as head */ if [head == null] { new_node.prev = null; head = new_node; return; } /* 5. Else traverse till the last node */ while [last.next != null] last = last.next; /* 6. Change the next of last node */ last.next = new_node; /* 7. Make last node as previous of new node */ new_node.prev = last; } // This code is contributed by shivanisinghss2110

// Add a node at the end of the list function append[new_data] { /* 1. allocate node * 2. put in the data */ var new_node = new Node[new_data]; var last = head; /* used in step 5*/ /* 3. This new node is going to be the last node, so * make next of it as NULL*/ new_node.next = null; /* 4. If the Linked List is empty, then make the new * node as head */ if [head == null] { new_node.prev = null; head = new_node; return; } /* 5. Else traverse till the last node */ while [last.next != null] last = last.next; /* 6. Change the next of last node */ last.next = new_node; /* 7. Make last node as previous of new node */ new_node.prev = last; } // This code is contributed by Rajput-Ji

// A complete working C++ program to // demonstrate all insertion methods #include using namespace std; // A linked list node class Node { public: int data; Node* next; Node* prev; }; /* Given a reference [pointer to pointer] to the head of a list and an int, inserts a new node on the front of the list. */ void push[Node** head_ref, int new_data] { /* 1. allocate node */ Node* new_node = new Node[]; /* 2. put in the data */ new_node->data = new_data; /* 3. Make next of new node as head and previous as NULL */ new_node->next = [*head_ref]; new_node->prev = NULL; /* 4. change prev of head node to new node */ if [[*head_ref] != NULL] [*head_ref]->prev = new_node; /* 5. move the head to point to the new node */ [*head_ref] = new_node; } /* Given a node as prev_node, insert a new node after the given node */ void insertAfter[Node* prev_node, int new_data] { /*1. check if the given prev_node is NULL */ if [prev_node == NULL] { coutnext = prev_node->next; /* 5. Make the next of prev_node as new_node */ prev_node->next = new_node; /* 6. Make prev_node as previous of new_node */ new_node->prev = prev_node; /* 7. Change previous of new_node's next node */ if [new_node->next != NULL] new_node->next->prev = new_node; } /* Given a reference [pointer to pointer] to the head of a DLL and an int, appends a new node at the end */ void append[Node** head_ref, int new_data] { /* 1. allocate node */ Node* new_node = new Node[]; Node* last = *head_ref; /* used in step 5*/ /* 2. put in the data */ new_node->data = new_data; /* 3. This new node is going to be the last node, so make next of it as NULL*/ new_node->next = NULL; /* 4. If the Linked List is empty, then make the new node as head */ if [*head_ref == NULL] { new_node->prev = NULL; *head_ref = new_node; return; } /* 5. Else traverse till the last node */ while [last->next != NULL] last = last->next; /* 6. Change the next of last node */ last->next = new_node; /* 7. Make last node as previous of new node */ new_node->prev = last; return; } // This function prints contents of // linked list starting from the given node void printList[Node* node] { Node* last; cout8->6->4->NULL insertAfter[head->next, 8]; cout data = new_data; /* 3. Make next of new node as head and previous as NULL */ new_node->next = [*head_ref]; new_node->prev = NULL; /* 4. change prev of head node to new node */ if [[*head_ref] != NULL] [*head_ref]->prev = new_node; /* 5. move the head to point to the new node */ [*head_ref] = new_node; } /* Given a node as prev_node, insert a new node after the * given node */ void insertAfter[struct Node* prev_node, int new_data] { /*1. check if the given prev_node is NULL */ if [prev_node == NULL] { printf["the given previous node cannot be NULL"]; return; } /* 2. allocate new node */ struct Node* new_node = [struct Node*]malloc[sizeof[struct Node]]; /* 3. put in the data */ new_node->data = new_data; /* 4. Make next of new node as next of prev_node */ new_node->next = prev_node->next; /* 5. Make the next of prev_node as new_node */ prev_node->next = new_node; /* 6. Make prev_node as previous of new_node */ new_node->prev = prev_node; /* 7. Change previous of new_node's next node */ if [new_node->next != NULL] new_node->next->prev = new_node; } /* Given a reference [pointer to pointer] to the head of a DLL and an int, appends a new node at the end */ void append[struct Node** head_ref, int new_data] { /* 1. allocate node */ struct Node* new_node = [struct Node*]malloc[sizeof[struct Node]]; struct Node* last = *head_ref; /* used in step 5*/ /* 2. put in the data */ new_node->data = new_data; /* 3. This new node is going to be the last node, so make next of it as NULL*/ new_node->next = NULL; /* 4. If the Linked List is empty, then make the new node as head */ if [*head_ref == NULL] { new_node->prev = NULL; *head_ref = new_node; return; } /* 5. Else traverse till the last node */ while [last->next != NULL] last = last->next; /* 6. Change the next of last node */ last->next = new_node; /* 7. Make last node as previous of new node */ new_node->prev = last; return; } // This function prints contents of linked list starting // from the given node void printList[struct Node* node] { struct Node* last; printf["\nTraversal in forward direction \n"]; while [node != NULL] { printf[" %d ", node->data]; last = node; node = node->next; } printf["\nTraversal in reverse direction \n"]; while [last != NULL] { printf[" %d ", last->data]; last = last->prev; } } /* Driver program to test above functions*/ int main[] { /* Start with the empty list */ struct Node* head = NULL; // Insert 6. So linked list becomes 6->NULL append[&head, 6]; // Insert 7 at the beginning. So linked list becomes // 7->6->NULL push[&head, 7]; // Insert 1 at the beginning. So linked list becomes // 1->7->6->NULL push[&head, 1]; // Insert 4 at the end. So linked list becomes // 1->7->6->4->NULL append[&head, 4]; // Insert 8, after 7. So linked list becomes // 1->7->8->6->4->NULL insertAfter[head->next, 8]; printf["Created DLL is: "]; printList[head]; getchar[]; return 0; }

// A complete working Java program to demonstrate all // Class for Doubly Linked List public class DLL { Node head; // head of list /* Doubly Linked list Node*/ class Node { int data; Node prev; Node next; // Constructor to create a new node // next and prev is by default initialized as null Node[int d] { data = d; } } // Adding a node at the front of the list public void push[int new_data] { /* 1. allocate node * 2. put in the data */ Node new_Node = new Node[new_data]; /* 3. Make next of new node as head and previous as NULL */ new_Node.next = head; new_Node.prev = null; /* 4. change prev of head node to new node */ if [head != null] head.prev = new_Node; /* 5. move the head to point to the new node */ head = new_Node; } // Add a node before the given node public void InsertBefore[Node next_node, int new_data] { /*Check if the given nx_node is NULL*/ if[next_node == null] { System.out.println["The given next node can not be NULL"]; return; } //Allocate node, put in the data Node new_node = new Node[new_data]; //Making prev of new node as prev of next node new_node.prev = next_node.prev; //Making prev of next node as new node next_node.prev = new_node; //Making next of new node as next node new_node.next = next_node; //Check if new node is added as head if[new_node.prev != null] new_node.prev.next = new_node; else head = new_node; } /* Given a node as prev_node, insert a new node after the given node */ public void InsertAfter[Node prev_Node, int new_data] { /*1. check if the given prev_node is NULL */ if [prev_Node == null] { System.out.println["The given previous node cannot be NULL "]; return; } /* 2. allocate node * 3. put in the data */ Node new_node = new Node[new_data]; /* 4. Make next of new node as next of prev_node */ new_node.next = prev_Node.next; /* 5. Make the next of prev_node as new_node */ prev_Node.next = new_node; /* 6. Make prev_node as previous of new_node */ new_node.prev = prev_Node; /* 7. Change previous of new_node's next node */ if [new_node.next != null] new_node.next.prev = new_node; } // Add a node at the end of the list void append[int new_data] { /* 1. allocate node * 2. put in the data */ Node new_node = new Node[new_data]; Node last = head; /* used in step 5*/ /* 3. This new node is going to be the last node, so * make next of it as NULL*/ new_node.next = null; /* 4. If the Linked List is empty, then make the new * node as head */ if [head == null] { new_node.prev = null; head = new_node; return; } /* 5. Else traverse till the last node */ while [last.next != null] last = last.next; /* 6. Change the next of last node */ last.next = new_node; /* 7. Make last node as previous of new node */ new_node.prev = last; } // This function prints contents of // linked list starting from the given node public void printlist[Node node] { Node last = null; System.out.println["Traversal in forward Direction"]; while [node != null] { System.out.print[node.data + " "]; last = node; node = node.next; } System.out.println[]; System.out.println["Traversal in reverse direction"]; while [last != null] { System.out.print[last.data + " "]; last = last.prev; } } /* Driver program to test above functions*/ public static void main[String[] args] { /* Start with the empty list */ DLL dll = new DLL[]; // Insert 6. So linked list becomes 6->NULL dll.append[6]; // Insert 7 at the beginning. So // linked list becomes 7->6->NULL dll.push[7]; // Insert 1 at the beginning. So // linked list becomes 1->7->6->NULL dll.push[1]; // Insert 4 at the end. So linked // list becomes 1->7->6->4->NULL dll.append[4]; // Insert 8, after 7. So linked // list becomes 1->7->8->6->4->NULL dll.InsertAfter[dll.head.next, 8]; // Insert 5, before 8.So linked // list becomes 1->7->5->8->6->4 dll.InsertBefore[dll.head.next.next, 5]; System.out.println["Created DLL is: "]; dll.printlist[dll.head]; } } // This code is contributed by Sumit Ghosh

# A complete working Python # program to demonstrate all # insertion methods # A linked list node class Node: # Constructor to create a new node def __init__[self, data]: self.data = data self.next = None self.prev = None # Class to create a Doubly Linked List class DoublyLinkedList: # Constructor for empty Doubly Linked List def __init__[self]: self.head = None # Given a reference to the head of a list and an # integer, inserts a new node on the front of list def push[self, new_data]: # 1. Allocates node # 2. Put the data in it new_node = Node[new_data] # 3. Make next of new node as head and # previous as None [already None] new_node.next = self.head # 4. change prev of head node to new_node if self.head is not None: self.head.prev = new_node # 5. move the head to point to the new node self.head = new_node # Given a node as prev_node, insert a new node after # the given node def insertAfter[self, prev_node, new_data]: # 1. Check if the given prev_node is None if prev_node is None: print["the given previous node cannot be NULL"] return # 2. allocate new node # 3. put in the data new_node = Node[new_data] # 4. Make net of new node as next of prev node new_node.next = prev_node.next # 5. Make prev_node as previous of new_node prev_node.next = new_node # 6. Make prev_node ass previous of new_node new_node.prev = prev_node # 7. Change previous of new_nodes's next node if new_node.next: new_node.next.prev = new_node # Given a reference to the head of DLL and integer, # appends a new node at the end def append[self, new_data]: # 1. Allocates node # 2. Put in the data new_node = Node[new_data] # 3. This new node is going to be the last node, # so make next of it as None # [It already is initialized as None] # 4. If the Linked List is empty, then make the # new node as head if self.head is None: self.head = new_node return # 5. Else traverse till the last node last = self.head while last.next: last = last.next # 6. Change the next of last node last.next = new_node # 7. Make last node as previous of new node new_node.prev = last return # This function prints contents of linked list # starting from the given node def printList[self, node]: print["\nTraversal in forward direction"] while node: print[" {}".format[node.data]] last = node node = node.next print["\nTraversal in reverse direction"] while last: print[" {}".format[last.data]] last = last.prev # Driver program to test above functions # Start with empty list llist = DoublyLinkedList[] # Insert 6. So the list becomes 6->None llist.append[6] # Insert 7 at the beginning. # So linked list becomes 7->6->None llist.push[7] # Insert 1 at the beginning. # So linked list becomes 1->7->6->None llist.push[1] # Insert 4 at the end. # So linked list becomes 1->7->6->4->None llist.append[4] # Insert 8, after 7. # So linked list becomes 1->7->8->6->4->None llist.insertAfter[llist.head.next, 8] print ["Created DLL is: "] llist.printList[llist.head] # This code is contributed by Nikhil Kumar Singh[nickzuck_007]

// A complete working C# program to demonstrate all using System; // Class for Doubly Linked List public class DLL { Node head; // head of list /* Doubly Linked list Node*/ public class Node { public int data; public Node prev; public Node next; // Constructor to create a new node // next and prev is by default initialized as null public Node[int d] { data = d; } } // Adding a node at the front of the list public void push[int new_data] { /* 1. allocate node * 2. put in the data */ Node new_Node = new Node[new_data]; /* 3. Make next of new node as head and previous as NULL */ new_Node.next = head; new_Node.prev = null; /* 4. change prev of head node to new node */ if [head != null] head.prev = new_Node; /* 5. move the head to point to the new node */ head = new_Node; } /* Given a node as prev_node, insert a new node after the given node */ public void InsertAfter[Node prev_Node, int new_data] { /*1. check if the given prev_node is NULL */ if [prev_Node == null] { Console.WriteLine["The given previous node cannot be NULL "]; return; } /* 2. allocate node * 3. put in the data */ Node new_node = new Node[new_data]; /* 4. Make next of new node as next of prev_node */ new_node.next = prev_Node.next; /* 5. Make the next of prev_node as new_node */ prev_Node.next = new_node; /* 6. Make prev_node as previous of new_node */ new_node.prev = prev_Node; /* 7. Change previous of new_node's next node */ if [new_node.next != null] new_node.next.prev = new_node; } // Add a node at the end of the list void append[int new_data] { /* 1. allocate node * 2. put in the data */ Node new_node = new Node[new_data]; Node last = head; /* used in step 5*/ /* 3. This new node is going to be the last node, so * make next of it as NULL*/ new_node.next = null; /* 4. If the Linked List is empty, then make the new * node as head */ if [head == null] { new_node.prev = null; head = new_node; return; } /* 5. Else traverse till the last node */ while [last.next != null] last = last.next; /* 6. Change the next of last node */ last.next = new_node; /* 7. Make last node as previous of new node */ new_node.prev = last; } // This function prints contents of // linked list starting from the given node public void printlist[Node node] { Node last = null; Console.WriteLine["Traversal in forward Direction"]; while [node != null] { Console.Write[node.data + " "]; last = node; node = node.next; } Console.WriteLine[]; Console.WriteLine["Traversal in reverse direction"]; while [last != null] { Console.Write[last.data + " "]; last = last.prev; } } /* Driver code*/ public static void Main[String[] args] { /* Start with the empty list */ DLL dll = new DLL[]; // Insert 6. So linked list becomes 6->NULL dll.append[6]; // Insert 7 at the beginning. // So linked list becomes 7->6->NULL dll.push[7]; // Insert 1 at the beginning. // So linked list becomes 1->7->6->NULL dll.push[1]; // Insert 4 at the end. So linked list // becomes 1->7->6->4->NULL dll.append[4]; // Insert 8, after 7. So linked list // becomes 1->7->8->6->4->NULL dll.InsertAfter[dll.head.next, 8]; Console.WriteLine["Created DLL is: "]; dll.printlist[dll.head]; } } // This code is contributed by 29AjayKumar