Types of Linked List
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.
Types Of Linked 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; }; |
chevron_right
filter_none
- Creation and Traversal of Singly Linked List:
C++
// C++ program to illustrate creation // and traversal of Singly Linked List #include <bits/stdc++.h> 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; } |
chevron_right
filter_none
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 |
chevron_right
filter_none
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 |
chevron_right
filter_none
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; }; |
chevron_right
filter_none
- Creation and Traversal of Doubly Linked List:
C++
// C++ program to illustrate creation // and traversal of Doubly Linked List #include <bits/stdc++.h> 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; } |
chevron_right
filter_none
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 |
chevron_right
filter_none
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 |
chevron_right
filter_none
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; }; |
chevron_right
filter_none
- Creation and Traversal of Circular Linked List:
C++
// C++ program to illustrate creation // and traversal of Circular LL #include <bits/stdc++.h> 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; } |
chevron_right
filter_none
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 |
chevron_right
filter_none
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 |
chevron_right
filter_none
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; }; |
chevron_right
filter_none
- Creation and Traversal of Doubly Circular Linked List:
C++
// C++ program to illustrate creation // & traversal of Doubly Circular LL #include <bits/stdc++.h> 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; } |
chevron_right
filter_none
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 |
chevron_right
filter_none
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 |
chevron_right
filter_none
Output
Created circular doubly linked list is: Traversal in forward direction 7 4 5 Traversal in reverse direction 5 4 7
- Header Linked List: A header linked list is a special type of linked list which contains a header node at the beginning of the list. So, in a header linked list START will not point to the first node of the list but START will contain the address of the header node. Below is the image for Grounded Header Linked List:
- Structure of Grounded Header Linked List:
C++
// Structure of the list struct link { int info; // Pointer to the next node struct link* next; }; |
chevron_right
filter_none
- Creation and Traversal of Header Linked List:
C++
// C++ program to illustrate creation // and traversal of Header Linked List #include <bits/stdc++.h> // #include <malloc.h> // #include <stdio.h> // 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; } |
chevron_right
filter_none
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 |
chevron_right
filter_none
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 |
chevron_right
filter_none
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.