Related Articles
• Last Updated : 14 Dec, 2020

A linked list is a linear data structure, in which the elements are not stored at contiguous memory locations. The elements in a linked list are linked using pointers. In simple words, a linked list consists of nodes where each node contains a data field and a reference(link) to the next node in the list.

• Singly Linked List: It is the simplest type of linked list in which every node contains some data and a pointer to the next node of the same data type. The node contains a pointer to the next node means that the node stores the address of the next node in the sequence. A single linked list allows traversal of data only in one way. Below is the image for the same: • Structure of Singly Linked List:

## C++

 `// Node of a doubly linked list` `class` `Node {` `public``:` `    ``int` `data;`   `    ``// Pointer to next node in LL` `    ``Node* next;` `};`

• Creation and Traversal of Singly Linked List:

## C++

 `// C++ program to illustrate creation` `// and traversal of Singly Linked List`   `#include ` `using` `namespace` `std;`   `// Structure of Node` `class` `Node {` `public``:` `    ``int` `data;` `    ``Node* next;` `};`   `// Function to print the content of` `// linked list starting from the` `// given node` `void` `printList(Node* n)` `{`   `    ``// Iterate till n reaches NULL` `    ``while` `(n != NULL) {`   `        ``// Print the data` `        ``cout << n->data << ``" "``;` `        ``n = n->next;` `    ``}` `}`   `// Driver Code` `int` `main()` `{` `    ``Node* head = NULL;` `    ``Node* second = NULL;` `    ``Node* third = NULL;`   `    ``// Allocate 3 nodes in the heap` `    ``head = ``new` `Node();` `    ``second = ``new` `Node();` `    ``third = ``new` `Node();`   `    ``// Assign data in first node` `    ``head->data = 1;`   `    ``// Link first node with second` `    ``head->next = second;`   `    ``// Assign data to second node` `    ``second->data = 2;` `    ``second->next = third;`   `    ``// Assign data to third node` `    ``third->data = 3;` `    ``third->next = NULL;`   `    ``printList(head);`   `    ``return` `0;` `}`

## Java

 `// Java program to illustrate ` `// creation and traversal of ` `// Singly Linked List` `class` `GFG{`   `// Structure of Node` `static` `class` `Node ` `{` `  ``int` `data;` `  ``Node next;` `};`   `// Function to print the content of` `// linked list starting from the` `// given node` `static` `void` `printList(Node n)` `{` `  ``// Iterate till n reaches null` `  ``while` `(n != ``null``) ` `  ``{` `    ``// Print the data` `    ``System.out.print(n.data + ``" "``);` `    ``n = n.next;` `  ``}` `}`   `// Driver Code` `public` `static` `void` `main(String[] args)` `{` `  ``Node head = ``null``;` `  ``Node second = ``null``;` `  ``Node third = ``null``;`   `  ``// Allocate 3 nodes in ` `  ``// the heap` `  ``head = ``new` `Node();` `  ``second = ``new` `Node();` `  ``third = ``new` `Node();`   `  ``// Assign data in first` `  ``// node` `  ``head.data = ``1``;`   `  ``// Link first node with ` `  ``// second` `  ``head.next = second;`   `  ``// Assign data to second` `  ``// node` `  ``second.data = ``2``;` `  ``second.next = third;`   `  ``// Assign data to third ` `  ``// node` `  ``third.data = ``3``;` `  ``third.next = ``null``;`   `  ``printList(head);` `}` `}`   `// This code is contributed by Princi Singh`

## C#

 `// C# program to illustrate ` `// creation and traversal of ` `// Singly Linked List` `using` `System;`   `class` `GFG{`   `// Structure of Node` `public` `class` `Node ` `{` `    ``public` `int` `data;` `    ``public` `Node next;` `};`   `// Function to print the content of` `// linked list starting from the` `// given node` `static` `void` `printList(Node n)` `{` `    `  `    ``// Iterate till n reaches null` `    ``while` `(n != ``null``) ` `    ``{` `        `  `        ``// Print the data` `        ``Console.Write(n.data + ``" "``);` `        ``n = n.next;` `    ``}` `}`   `// Driver Code` `public` `static` `void` `Main(String[] args)` `{` `    ``Node head = ``null``;` `    ``Node second = ``null``;` `    ``Node third = ``null``;` `    `  `    ``// Allocate 3 nodes in ` `    ``// the heap` `    ``head = ``new` `Node();` `    ``second = ``new` `Node();` `    ``third = ``new` `Node();` `    `  `    ``// Assign data in first` `    ``// node` `    ``head.data = 1;` `    `  `    ``// Link first node with ` `    ``// second` `    ``head.next = second;` `    `  `    ``// Assign data to second` `    ``// node` `    ``second.data = 2;` `    ``second.next = third;` `    `  `    ``// Assign data to third ` `    ``// node` `    ``third.data = 3;` `    ``third.next = ``null``;` `    `  `    ``printList(head);` `}` `}`   `// This code is contributed by Amit Katiyar`

Output

`1 2 3`
• Doubly Linked List: A doubly linked list or a two-way linked list is a more complex type of linked list which contains a pointer to the next as well as the previous node in sequence, Therefore, it contains three parts are data, a pointer to the next node, and a pointer to the previous node. This would enable us to traverse the list in the backward direction as well. Below is the image for the same: • Structure of Doubly Linked List:

## C++

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

• Creation and Traversal of Doubly Linked List:

## C++

 `// C++ program to illustrate creation` `// and traversal of Doubly Linked List` `#include ` `using` `namespace` `std;`   `// Doubly linked list node` `class` `Node {` `public``:` `    ``int` `data;` `    ``Node* next;` `    ``Node* prev;` `};`   `// Function to push a new element in` `// the Doubly Linked List` `void` `push(Node** head_ref, ``int` `new_data)` `{` `    ``// Allocate node` `    ``Node* new_node = ``new` `Node();`   `    ``// Put in the data` `    ``new_node->data = new_data;`   `    ``// Make next of new node as` `    ``// head and previous as NULL` `    ``new_node->next = (*head_ref);` `    ``new_node->prev = NULL;`   `    ``// Change prev of head node to` `    ``// the new node` `    ``if` `((*head_ref) != NULL)` `        ``(*head_ref)->prev = new_node;`   `    ``// Move the head to point to` `    ``// the new node` `    ``(*head_ref) = new_node;` `}`   `// Function to traverse the Doubly LL` `// in the forward & backward direction` `void` `printList(Node* node)` `{` `    ``Node* last;`   `    ``cout << ``"\nTraversal in forward"` `         ``<< ``" direction \n"``;` `    ``while` `(node != NULL) {`   `        ``// Print the data` `        ``cout << ``" "` `<< node->data << ``" "``;` `        ``last = node;` `        ``node = node->next;` `    ``}`   `    ``cout << ``"\nTraversal in reverse"` `         ``<< ``" direction \n"``;` `    ``while` `(last != NULL) {`   `        ``// Print the data` `        ``cout << ``" "` `<< last->data << ``" "``;` `        ``last = last->prev;` `    ``}` `}`   `// Driver Code` `int` `main()` `{` `    ``// Start with the empty list` `    ``Node* head = NULL;`   `    ``// Insert 6.` `    ``// So linked list becomes 6->NULL` `    ``push(&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);`   `    ``cout << ``"Created DLL is: "``;` `    ``printList(head);`   `    ``return` `0;` `}`

## Java

 `// Java program to illustrate ` `// creation and traversal of ` `// Doubly Linked List` `import` `java.util.*;` `class` `GFG{`   `// Doubly linked list ` `// node` `static` `class` `Node ` `{` `  ``int` `data;` `  ``Node next;` `  ``Node prev;` `};` `  `  `static` `Node head_ref;` `  `  `// Function to push a new ` `// element in the Doubly ` `// Linked List` `static` `void` `push(``int` `new_data)` `{` `  ``// Allocate node` `  ``Node new_node = ``new` `Node();`   `  ``// Put in the data` `  ``new_node.data = new_data;`   `  ``// Make next of new node as` `  ``// head and previous as null` `  ``new_node.next = head_ref;` `  ``new_node.prev = ``null``;`   `  ``// Change prev of head node to` `  ``// the new node` `  ``if` `(head_ref != ``null``)` `    ``head_ref.prev = new_node;`   `  ``// Move the head to point to` `  ``// the new node` `  ``head_ref = new_node;` `}`   `// Function to traverse the ` `// Doubly LL in the forward ` `// & backward direction` `static` `void` `printList(Node node)` `{` `  ``Node last = ``null``;`   `  ``System.out.print(``"\nTraversal in forward"` `+ ` `                   ``" direction \n"``);` `  ``while` `(node != ``null``) ` `  ``{` `    ``// Print the data` `    ``System.out.print(``" "` `+  node.data + ` `                     ``" "``);` `    ``last = node;` `    ``node = node.next;` `  ``}`   `  ``System.out.print(``"\nTraversal in reverse"` `+ ` `                   ``" direction \n"``);` `  `  `  ``while` `(last != ``null``) ` `  ``{` `    ``// Print the data` `    ``System.out.print(``" "` `+  last.data + ` `                     ``" "``);` `    ``last = last.prev;` `  ``}` `}`   `// Driver Code` `public` `static` `void` `main(String[] args)` `{` `  ``// Start with the empty list` `  ``head_ref = ``null``;`   `  ``// Insert 6.` `  ``// So linked list becomes ` `  ``// 6.null` `  ``push(``6``);`   `  ``// Insert 7 at the beginning. ` `  ``// So linked list becomes ` `  ``// 7.6.null` `  ``push(``7``);`   `  ``// Insert 1 at the beginning. ` `  ``// So linked list becomes ` `  ``// 1.7.6.null` `  ``push(``1``);`   `  ``System.out.print(``"Created DLL is: "``);` `  ``printList(head_ref);` `}` `}`   `// This code is contributed by Princi Singh`

## C#

 `// C# program to illustrate ` `// creation and traversal of ` `// Doubly Linked List` `using` `System;`   `class` `GFG{`   `// Doubly linked list ` `// node` `public` `class` `Node ` `{` `  ``public` `int` `data;` `  ``public` `Node next;` `  ``public` `Node prev;` `};` `  `  `static` `Node head_ref;` `  `  `// Function to push a new ` `// element in the Doubly ` `// Linked List` `static` `void` `push(``int` `new_data)` `{` `  `  `  ``// Allocate node` `  ``Node new_node = ``new` `Node();`   `  ``// Put in the data` `  ``new_node.data = new_data;`   `  ``// Make next of new node as` `  ``// head and previous as null` `  ``new_node.next = head_ref;` `  ``new_node.prev = ``null``;`   `  ``// Change prev of head node to` `  ``// the new node` `  ``if` `(head_ref != ``null``)` `    ``head_ref.prev = new_node;`   `  ``// Move the head to point to` `  ``// the new node` `  ``head_ref = new_node;` `}`   `// Function to traverse the ` `// Doubly LL in the forward ` `// & backward direction` `static` `void` `printList(Node node)` `{` `  ``Node last = ``null``;`   `  ``Console.Write(``"\nTraversal in forward"` `+ ` `                ``" direction \n"``);` `  `  `  ``while` `(node != ``null``) ` `  ``{` `    `  `    ``// Print the data` `    ``Console.Write(``" "` `+  node.data + ` `                  ``" "``);` `    ``last = node;` `    ``node = node.next;` `  ``}`   `  ``Console.Write(``"\nTraversal in reverse"` `+ ` `                ``" direction \n"``);` `  `  `  ``while` `(last != ``null``) ` `  ``{` `    `  `    ``// Print the data` `    ``Console.Write(``" "` `+  last.data + ` `                  ``" "``);` `    ``last = last.prev;` `  ``}` `}`   `// Driver Code` `public` `static` `void` `Main(String[] args)` `{` `  `  `  ``// Start with the empty list` `  ``head_ref = ``null``;`   `  ``// Insert 6.` `  ``// So linked list becomes ` `  ``// 6.null` `  ``push(6);`   `  ``// Insert 7 at the beginning. ` `  ``// So linked list becomes ` `  ``// 7.6.null` `  ``push(7);`   `  ``// Insert 1 at the beginning. ` `  ``// So linked list becomes ` `  ``// 1.7.6.null` `  ``push(1);`   `  ``Console.Write(``"Created DLL is: "``);` `  ``printList(head_ref);` `}` `}`   `// This code is contributed by Amit Katiyar`

Output

```Created DLL is:
Traversal in forward direction
1  7  6
Traversal in reverse direction
6  7  1```
• Circular Linked List: A circular linked list is that in which the last node contains the pointer to the first node of the list. While traversing a circular liked list, we can begin at any node and traverse the list in any direction forward and backward until we reach the same node we started. Thus, a circular linked list has no beginning and no end. Below is the image for the same: • Structure of Circular Linked List:

## C++

 `// Structure for a node` `class` `Node {` `public``:` `    ``int` `data;`   `    ``// Pointer to next node in CLL` `    ``Node* next;` `};`

• Creation and Traversal of Circular Linked List:

## C++

 `// C++ program to illustrate creation` `// and traversal of Circular LL` `#include ` `using` `namespace` `std;`   `// Structure for a node` `class` `Node {` `public``:` `    ``int` `data;` `    ``Node* next;` `};`   `// Function to insert a node at the` `// beginning of Circular LL` `void` `push(Node** head_ref, ``int` `data)` `{` `    ``Node* ptr1 = ``new` `Node();` `    ``Node* temp = *head_ref;` `    ``ptr1->data = data;` `    ``ptr1->next = *head_ref;`   `    ``// If linked list is not NULL then` `    ``// set the next of last node` `    ``if` `(*head_ref != NULL) {` `        ``while` `(temp->next != *head_ref) {` `            ``temp = temp->next;` `        ``}` `        ``temp->next = ptr1;` `    ``}`   `    ``// For the first node` `    ``else` `        ``ptr1->next = ptr1;`   `    ``*head_ref = ptr1;` `}`   `// Function to print nodes in the` `// Circular Linked List` `void` `printList(Node* head)` `{` `    ``Node* temp = head;` `    ``if` `(head != NULL) {` `        ``do` `{`   `            ``// Print the data` `            ``cout << temp->data << ``" "``;` `            ``temp = temp->next;` `        ``} ``while` `(temp != head);` `    ``}` `}`   `// Driver Code` `int` `main()` `{` `    ``// Initialize list as empty` `    ``Node* head = NULL;`   `    ``// Created linked list will` `    ``// be 11->2->56->12` `    ``push(&head, 12);` `    ``push(&head, 56);` `    ``push(&head, 2);` `    ``push(&head, 11);`   `    ``cout << ``"Contents of Circular"` `         ``<< ``" Linked List\n "``;` `    ``printList(head);`   `    ``return` `0;` `}`

## Java

 `// Java program to illustrate ` `// creation and traversal of ` `// Circular LL` `import` `java.util.*;` `class` `GFG{`   `// Structure for a ` `// node` `static` `class` `Node ` `{` `  ``int` `data;` `  ``Node next;` `};`   `// Function to insert a node` `// at the beginning of Circular ` `// LL` `static` `Node push(Node head_ref, ` `                 ``int` `data)` `{` `  ``Node ptr1 = ``new` `Node();` `  ``Node temp = head_ref;` `  ``ptr1.data = data;` `  ``ptr1.next = head_ref;`   `  ``// If linked list is not ` `  ``// null then set the next ` `  ``// of last node` `  ``if` `(head_ref != ``null``) ` `  ``{` `    ``while` `(temp.next != head_ref) ` `    ``{` `      ``temp = temp.next;` `    ``}` `    ``temp.next = ptr1;` `  ``}`   `  ``// For the first node` `  ``else` `    ``ptr1.next = ptr1;`   `  ``head_ref = ptr1;` `  ``return` `head_ref;` `}`   `// Function to print nodes in ` `// the Circular Linked List` `static` `void` `printList(Node head)` `{` `  ``Node temp = head;` `  ``if` `(head != ``null``) ` `  ``{` `    ``do` `    ``{` `      ``// Print the data` `      ``System.out.print(temp.data + ``" "``);` `      ``temp = temp.next;` `    ``} ``while` `(temp != head);` `  ``}` `}`   `// Driver Code` `public` `static` `void` `main(String[] args)` `{` `  ``// Initialize list as empty` `  ``Node head = ``null``;`   `  ``// Created linked list will` `  ``// be 11.2.56.12` `  ``head = push(head, ``12``);` `  ``head = push(head, ``56``);` `  ``head = push(head, ``2``);` `  ``head = push(head, ``11``);`   `  ``System.out.print(``"Contents of Circular"` `+ ` `                   ``" Linked List\n "``);` `  ``printList(head);` `}` `}`   `// This code is contributed by gauravrajput1`

## C#

 `// C# program to illustrate ` `// creation and traversal of ` `// Circular LL` `using` `System;`   `class` `GFG{`   `// Structure for a ` `// node` `public` `class` `Node ` `{` `  ``public` `int` `data;` `  ``public` `Node next;` `};`   `// Function to insert a node` `// at the beginning of Circular ` `// LL` `static` `Node push(Node head_ref, ` `                 ``int` `data)` `{` `  ``Node ptr1 = ``new` `Node();` `  ``Node temp = head_ref;` `  ``ptr1.data = data;` `  ``ptr1.next = head_ref;` `  `  `  ``// If linked list is not ` `  ``// null then set the next ` `  ``// of last node` `  ``if` `(head_ref != ``null``) ` `  ``{` `    ``while` `(temp.next != head_ref) ` `    ``{` `      ``temp = temp.next;` `    ``}` `    ``temp.next = ptr1;` `  ``}`   `  ``// For the first node` `  ``else` `    ``ptr1.next = ptr1;`   `  ``head_ref = ptr1;` `  ``return` `head_ref;` `}`   `// Function to print nodes in ` `// the Circular Linked List` `static` `void` `printList(Node head)` `{` `  ``Node temp = head;` `  `  `  ``if` `(head != ``null``) ` `  ``{` `    ``do` `    ``{` `      `  `      ``// Print the data` `      ``Console.Write(temp.data + ``" "``);` `      ``temp = temp.next;` `    ``} ``while` `(temp != head);` `  ``}` `}`   `// Driver Code` `public` `static` `void` `Main(String[] args)` `{` `  `  `  ``// Initialize list as empty` `  ``Node head = ``null``;` `  `  `  ``// Created linked list will` `  ``// be 11.2.56.12` `  ``head = push(head, 12);` `  ``head = push(head, 56);` `  ``head = push(head, 2);` `  ``head = push(head, 11);`   `  ``Console.Write(``"Contents of Circular "` `+ ` `                ``"Linked List\n "``);` `  `  `  ``printList(head);` `}` `}`   `// This code is contributed by gauravrajput1`

Output

```Contents of Circular Linked List
11 2 56 12```
• Doubly Circular linked list: A Doubly Circular linked list or a circular two-way linked list is a more complex type of linked-list that contains a pointer to the next as well as the previous node in the sequence. The difference between the doubly linked and circular doubly list is the same as that between a singly linked list and a circular linked list. The circular doubly linked list does not contain null in the previous field of the first node. Below is the image for the same: • Structure of Doubly Circular Linked List:

## C++

 `// Node of doubly circular linked list` `struct` `Node {`   `    ``int` `data;`   `    ``// Pointer to next node in DCLL` `    ``struct` `Node* next;`   `    ``// Pointer to the previous node in DCLL` `    ``struct` `Node* prev;` `};`

• Creation and Traversal of Doubly Circular Linked List:

## C++

 `// C++ program to illustrate creation` `// & traversal of Doubly Circular LL` `#include ` `using` `namespace` `std;`   `// Structure of a Node` `struct` `Node {` `    ``int` `data;` `    ``struct` `Node* next;` `    ``struct` `Node* prev;` `};`   `// Function to insert Node at` `// the beginning of the List` `void` `insertBegin(``struct` `Node** start,` `                 ``int` `value)` `{` `    ``// If the list is empty` `    ``if` `(*start == NULL) {` `        ``struct` `Node* new_node = ``new` `Node;` `        ``new_node->data = value;` `        ``new_node->next` `            ``= new_node->prev = new_node;` `        ``*start = new_node;` `        ``return``;` `    ``}`   `    ``// Pointer points to last Node` `    ``struct` `Node* last = (*start)->prev;`   `    ``struct` `Node* new_node = ``new` `Node;`   `    ``// Inserting the data` `    ``new_node->data = value;`   `    ``// Update the previous and` `    ``// next of new node` `    ``new_node->next = *start;` `    ``new_node->prev = last;`   `    ``// Update next and previous` `    ``// pointers of start & last` `    ``last->next = (*start)->prev` `        ``= new_node;`   `    ``// Update start pointer` `    ``*start = new_node;` `}`   `// Function to traverse the circular` `// doubly linked list` `void` `display(``struct` `Node* start)` `{` `    ``struct` `Node* temp = start;`   `    ``printf``(``"\nTraversal in"` `           ``" forward direction \n"``);` `    ``while` `(temp->next != start) {` `        ``printf``(``"%d "``, temp->data);` `        ``temp = temp->next;` `    ``}` `    ``printf``(``"%d "``, temp->data);`   `    ``printf``(``"\nTraversal in "` `           ``"reverse direction \n"``);` `    ``Node* last = start->prev;` `    ``temp = last;`   `    ``while` `(temp->prev != last) {`   `        ``// Print the data` `        ``printf``(``"%d "``, temp->data);` `        ``temp = temp->prev;` `    ``}` `    ``printf``(``"%d "``, temp->data);` `}`   `// Driver Code` `int` `main()` `{` `    ``// Start with the empty list` `    ``struct` `Node* start = NULL;`   `    ``// Insert 5` `    ``// So linked list becomes 5->NULL` `    ``insertBegin(&start, 5);`   `    ``// Insert 4 at the beginning` `    ``// So linked list becomes 4->5` `    ``insertBegin(&start, 4);`   `    ``// Insert 7 at the end` `    ``// So linked list becomes 7->4->5` `    ``insertBegin(&start, 7);`   `    ``printf``(``"Created circular doubly"` `           ``" linked list is: "``);` `    ``display(start);`   `    ``return` `0;` `}`

## Java

 `// Java program to illustrate creation` `// & traversal of Doubly Circular LL` `import` `java.util.*;`   `class` `GFG{`   `// Structure of a Node` `static` `class` `Node` `{` `    ``int` `data;` `    ``Node next;` `    ``Node prev;` `};` `  `  `// Start with the empty list` `static` `Node start = ``null``;`   `// Function to insert Node at` `// the beginning of the List` `static` `void` `insertBegin(` `                 ``int` `value)` `{` `    ``// If the list is empty` `    ``if` `(start == ``null``) ` `    ``{` `        ``Node new_node = ``new` `Node();` `        ``new_node.data = value;` `        ``new_node.next` `            ``= new_node.prev = new_node;` `        ``start = new_node;` `        ``return``;` `    ``}`   `    ``// Pointer points to last Node` `    ``Node last = (start).prev;`   `    ``Node new_node = ``new` `Node();`   `    ``// Inserting the data` `    ``new_node.data = value;`   `    ``// Update the previous and` `    ``// next of new node` `    ``new_node.next = start;` `    ``new_node.prev = last;`   `    ``// Update next and previous` `    ``// pointers of start & last` `    ``last.next = (start).prev` `        ``= new_node;`   `    ``// Update start pointer` `    ``start = new_node;` `}`   `// Function to traverse the circular` `// doubly linked list` `static` `void` `display()` `{` `    ``Node temp = start;`   `    ``System.out.printf(``"\nTraversal in"` `           ``+``" forward direction \n"``);` `    ``while` `(temp.next != start)` `    ``{` `        ``System.out.printf(``"%d "``, temp.data);` `        ``temp = temp.next;` `    ``}` `    ``System.out.printf(``"%d "``, temp.data);`   `    ``System.out.printf(``"\nTraversal in "` `        ``+   ``"reverse direction \n"``);` `    ``Node last = start.prev;` `    ``temp = last;`   `    ``while` `(temp.prev != last)` `    ``{`   `        ``// Print the data` `        ``System.out.printf(``"%d "``, temp.data);` `        ``temp = temp.prev;` `    ``}` `    ``System.out.printf(``"%d "``, temp.data);` `}`   `// Driver Code` `public` `static` `void` `main(String[] args)` `{`   `    ``// Insert 5` `    ``// So linked list becomes 5.null` `    ``insertBegin( ``5``);`   `    ``// Insert 4 at the beginning` `    ``// So linked list becomes 4.5` `    ``insertBegin( ``4``);`   `    ``// Insert 7 at the end` `    ``// So linked list becomes 7.4.5` `    ``insertBegin( ``7``);`   `    ``System.out.printf(``"Created circular doubly"` `          ``+ ``" linked list is: "``);` `    ``display();` `}` `}`   `// This code is contributed by shikhasingrajput`

## C#

 `// C# program to illustrate creation` `// & traversal of Doubly Circular LL` `using` `System;`   `public` `class` `GFG{`   `// Structure of a Node` `public`     ` ``class` `Node` `{` `    ``public`     ` ``int` `data;` `    ``public`     ` ``Node next;` `    ``public`     ` ``Node prev;` `};` `  `  `// Start with the empty list` `static` `Node start = ``null``;`   `// Function to insert Node at` `// the beginning of the List` `static` `void` `insertBegin(` `                 ``int` `value)` `{` `     ``Node new_node = ``new` `Node();` `  `  `    ``// If the list is empty` `    ``if` `(start == ``null``) ` `    ``{` `       `  `        ``new_node.data = value;` `        ``new_node.next` `            ``= new_node.prev = new_node;` `        ``start = new_node;` `        ``return``;` `    ``}`   `    ``// Pointer points to last Node` `    ``Node last = (start).prev;`   `    ``// Inserting the data` `    ``new_node.data = value;`   `    ``// Update the previous and` `    ``// next of new node` `    ``new_node.next = start;` `    ``new_node.prev = last;`   `    ``// Update next and previous` `    ``// pointers of start & last` `    ``last.next = (start).prev` `        ``= new_node;`   `    ``// Update start pointer` `    ``start = new_node;` `}`   `// Function to traverse the circular` `// doubly linked list` `static` `void` `display()` `{` `    ``Node temp = start;`   `    ``Console.Write(``"\nTraversal in"` `           ``+``" forward direction \n"``);` `    ``while` `(temp.next != start)` `    ``{` `        ``Console.Write(temp.data + ``" "``);` `        ``temp = temp.next;` `    ``}` `    ``Console.Write(temp.data + ``" "``);`   `    ``Console.Write(``"\nTraversal in "` `        ``+   ``"reverse direction \n"``);` `    ``Node last = start.prev;` `    ``temp = last;`   `    ``while` `(temp.prev != last)` `    ``{`   `        ``// Print the data` `        ``Console.Write( temp.data + ``" "``);` `        ``temp = temp.prev;` `    ``}` `    ``Console.Write( temp.data + ``" "``);` `}`   `// Driver Code` `public` `static` `void` `Main(String[] args)` `{`   `    ``// Insert 5` `    ``// So linked list becomes 5.null` `    ``insertBegin( 5);`   `    ``// Insert 4 at the beginning` `    ``// So linked list becomes 4.5` `    ``insertBegin( 4);`   `    ``// Insert 7 at the end` `    ``// So linked list becomes 7.4.5` `    ``insertBegin( 7);`   `    ``Console.Write(``"Created circular doubly"` `          ``+ ``" linked list is: "``);` `    ``display();` `}` `}`   `// This code is contributed by 29AjayKumar `

Output

```Created circular doubly linked list is:
Traversal in forward direction
7 4 5
Traversal in reverse direction
5 4 7``` ## C++

 `// Structure of the list` `struct` `link {` `    ``int` `info;`   `    ``// Pointer to the next node` `    ``struct` `link* next;` `};`

• Creation and Traversal of Doubly Circular Linked List:

## C++

 `// C++ program to illustrate creation` `// and traversal of Header Linked List` `#include ` `// #include ` `// #include `   `// Structure of the list` `struct` `link {` `    ``int` `info;` `    ``struct` `link* next;` `};`   `// Empty List` `struct` `link* start = NULL;`   `// Function to create header of the` `// header linked list` `struct` `link* create_header_list(``int` `data)` `{`   `    ``// Create a new node` `    ``struct` `link *new_node, *node;` `    ``new_node = (``struct` `link*)` `        ``malloc``(``sizeof``(``struct` `link));` `    ``new_node->info = data;` `    ``new_node->next = NULL;`   `    ``// If it is the first node` `    ``if` `(start == NULL) {`   `        ``// Initialize the start` `        ``start = (``struct` `link*)` `            ``malloc``(``sizeof``(``struct` `link));` `        ``start->next = new_node;` `    ``}` `    ``else` `{`   `        ``// Insert the node in the end` `        ``node = start;` `        ``while` `(node->next != NULL) {` `            ``node = node->next;` `        ``}` `        ``node->next = new_node;` `    ``}` `    ``return` `start;` `}`   `// Function to display the` `// header linked list` `struct` `link* display()` `{` `    ``struct` `link* node;` `    ``node = start;` `    ``node = node->next;`   `    ``// Traverse until node is` `    ``// not NULL` `    ``while` `(node != NULL) {`   `        ``// Print the data` `        ``printf``(``"%d "``, node->info);` `        ``node = node->next;` `    ``}` `    ``printf``(``"\n"``);`   `    ``// Return the start pointer` `    ``return` `start;` `}`   `// Driver Code` `int` `main()` `{` `    ``// Create the list` `    ``create_header_list(11);` `    ``create_header_list(12);` `    ``create_header_list(13);`   `    ``// Print the list` `    ``printf``(``"List After inserting"` `           ``" 3 elements:\n"``);` `    ``display();` `    ``create_header_list(14);` `    ``create_header_list(15);`   `    ``// Print the list` `    ``printf``(``"List After inserting"` `           ``" 2 more elements:\n"``);` `    ``display();`   `    ``return` `0;` `}`

## Java

 `// Java program to illustrate creation` `// and traversal of Header Linked List`   `class` `GFG{` `// Structure of the list` `static` `class` `link {` `    ``int` `info;` `    ``link next;` `};`   `// Empty List` `static` `link start = ``null``;`   `// Function to create header of the` `// header linked list` `static` `link create_header_list(``int` `data)` `{`   `    ``// Create a new node` `    ``link new_node, node;` `    ``new_node = ``new` `link();` `    ``new_node.info = data;` `    ``new_node.next = ``null``;`   `    ``// If it is the first node` `    ``if` `(start == ``null``) {`   `        ``// Initialize the start` `        ``start = ``new` `link();` `        ``start.next = new_node;` `    ``}` `    ``else` `{`   `        ``// Insert the node in the end` `        ``node = start;` `        ``while` `(node.next != ``null``) {` `            ``node = node.next;` `        ``}` `        ``node.next = new_node;` `    ``}` `    ``return` `start;` `}`   `// Function to display the` `// header linked list` `static` `link display()` `{` `    ``link node;` `    ``node = start;` `    ``node = node.next;`   `    ``// Traverse until node is` `    ``// not null` `    ``while` `(node != ``null``) {`   `        ``// Print the data` `        ``System.out.printf(``"%d "``, node.info);` `        ``node = node.next;` `    ``}` `    ``System.out.printf(``"\n"``);`   `    ``// Return the start pointer` `    ``return` `start;` `}`   `// Driver Code` `public` `static` `void` `main(String[] args)` `{` `    ``// Create the list` `    ``create_header_list(``11``);` `    ``create_header_list(``12``);` `    ``create_header_list(``13``);`   `    ``// Print the list` `    ``System.out.printf(``"List After inserting"` `          ``+ ``" 3 elements:\n"``);` `    ``display();` `    ``create_header_list(``14``);` `    ``create_header_list(``15``);`   `    ``// Print the list` `    ``System.out.printf(``"List After inserting"` `          ``+ ``" 2 more elements:\n"``);` `    ``display();`   `}` `}`   `// This code is contributed by 29AjayKumar`

## C#

 `// C# program to illustrate creation` `// and traversal of Header Linked List`   `using` `System;`   `public` `class` `GFG{` `// Structure of the list` `public` `class` `link {` `    ``public` `int` `info;` `    ``public` `link next;` `};`   `// Empty List` `static` `link start = ``null``;`   `// Function to create header of the` `// header linked list` `static` `link create_header_list(``int` `data)` `{`   `    ``// Create a new node` `    ``link new_node, node;` `    ``new_node = ``new` `link();` `    ``new_node.info = data;` `    ``new_node.next = ``null``;`   `    ``// If it is the first node` `    ``if` `(start == ``null``) {`   `        ``// Initialize the start` `        ``start = ``new` `link();` `        ``start.next = new_node;` `    ``}` `    ``else` `{`   `        ``// Insert the node in the end` `        ``node = start;` `        ``while` `(node.next != ``null``) {` `            ``node = node.next;` `        ``}` `        ``node.next = new_node;` `    ``}` `    ``return` `start;` `}`   `// Function to display the` `// header linked list` `static` `link display()` `{` `    ``link node;` `    ``node = start;` `    ``node = node.next;`   `    ``// Traverse until node is` `    ``// not null` `    ``while` `(node != ``null``) {`   `        ``// Print the data` `        ``Console.Write(``"{0} "``, node.info);` `        ``node = node.next;` `    ``}` `    ``Console.Write(``"\n"``);`   `    ``// Return the start pointer` `    ``return` `start;` `}`   `// Driver Code` `public` `static` `void` `Main(String[] args)` `{` `    ``// Create the list` `    ``create_header_list(11);` `    ``create_header_list(12);` `    ``create_header_list(13);`   `    ``// Print the list` `    ``Console.Write(``"List After inserting"` `          ``+ ``" 3 elements:\n"``);` `    ``display();` `    ``create_header_list(14);` `    ``create_header_list(15);`   `    ``// Print the list` `    ``Console.Write(``"List After inserting"` `          ``+ ``" 2 more elements:\n"``);` `    ``display();`   `}` `}`   ` `    `// This code is contributed by 29AjayKumar`

Output

```List After inserting 3 elements:
11 12 13
List After inserting 2 more elements:
11 12 13 14 15```

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up
Recommended Articles
Page :