Skip to content
Related Articles

Related Articles

Improve Article

Types of Linked List

  • Difficulty Level : Basic
  • Last Updated : 23 Jul, 2021

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;
};

Java




// Node of a doubly linked list
static class Node
{
  int data;
   
   // Pointer to next node in LL
  Node next;
};
 
//this code is contributed by shivani

Python3




# structure of Node
class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

C#




// Structure of Node
public class Node
{
    public int data;
     
    // Pointer to next node in LL
    public Node next;
};
 
//this code is contributed by shivanisinghss2110

Javascript




// Node of a doubly linked list
class Node
{
    constructor()
    {
        this.data=0;
         
        // Pointer to next node
        this.next=null;
    }
}
 
// This code is contributed by SHUBHAMSINGH10
  • 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;
}

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

Python3




# structure of Node
class Node:
    def __init__(self, data):
        self.data = data
        self.next = None
 
 
class LinkedList:
    def __init__(self):
        self.head = None
        self.last_node = None
         
    # function to add elements to linked list
    def append(self, data):
        # if linked list is empty then last_node will be none so in if condition head will be created
        if self.last_node is None:
            self.head = Node(data)
            self.last_node = self.head
        # adding node to the tail of linked list
        else:
            self.last_node.next = Node(data)
            self.last_node = self.last_node.next
             
# function to print the content of linked list
    def display(self):
        current = self.head
      # traversing the linked list
        while current is not None:
          # at each node printing its data
            print(current.data, end=' ')
           # giving current next node
            current = current.next
        print()
 
 
if __name__ == '__main__':
    L = LinkedList()
    # adding elements to the linked list
    L.append(1)
    L.append(2)
    L.append(3)
    L.append(4)
    # displaying elements of linked list
    L.display()

Javascript




<script>
 
// JavaScript program to illustrate
// creation and traversal of
// Singly Linked List
 
// Structure of Node
class Node
{
    constructor()
    {
        this.data=0;
        this.next=null;
    }
}
 
// Function to print the content of
// linked list starting from the
// given node
function printList(n)
{
    // Iterate till n reaches null
  while (n != null)
  {
    // Print the data
    document.write(n.data + " ");
    n = n.next;
  }
}
 
// Driver Code
let head = null;
let second = null;
let 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 unknown2108
 
</script>
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;
};

Java




// Doubly linked list
// node
static class Node
{
    int data;
     
    // Pointer to next node in DLL
    Node next;
     
    // Pointer to the previous node in DLL
    Node prev;
};
 
// This code is contributed by shivani

Python3




# structure of Node
class Node:
    def __init__(self, data):
        self.previous = None
        self.data = data
        self.next = None

C#




// Doubly linked list
// node
public class Node
{
    public int data;
     
    // Pointer to next node in DLL
    public Node next;
     
    // Pointer to the previous node in DLL
    public Node prev;
};
 
// This code is contributed by shivanisinghss2110
  • 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;
}

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

Python3




# structure of Node
class Node:
    def __init__(self, data):
        self.previous = None
        self.data = data
        self.next = None
 
 
class DoublyLinkedList:
    def __init__(self):
        self.head = None
        self.start_node = None
        self.last_node = None
 
    # function to add elements to doubly linked list
    def append(self, data):
        # is doubly linked list is empty then last_node will be none so in if condition head will be created
        if self.last_node is None:
            self.head = Node(data)
            self.last_node = self.head
        # adding node to the tail of doubly linked list
        else:
            new_node = Node(data)
            self.last_node.next = new_node
            new_node.previous = self.last_node
            new_node.next = None
            self.last_node = new_node
 
    # function to printing and traversing the content of doubly linked list from left to right and right to left
    def display(self, Type):
        if Type == 'Left_To_Right':
            current = self.head
            while current is not None:
                print(current.data, end=' ')
                current = current.next
            print()
        else:
            current = self.last_node
            while current is not None:
                print(current.data, end=' ')
                current = current.previous
            print()
 
 
if __name__ == '__main__':
    L = DoublyLinkedList()
    L.append(1)
    L.append(2)
    L.append(3)
    L.append(4)
    L.display('Left_To_Right')
    L.display('Right_To_Left')

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;
};

Java




// Structure for a node
static class Node
{
  int data;
   
  // Pointer to next node in CLL
  Node next;
};
 
// This code is contributed by shivanisinghss2110

Python3




# structure of Node
class Node:
    def __init__(self, data):
        self.data = data
        self.next = 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;
}

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

Python3




# structure of Node
class Node:
    def __init__(self, data):
        self.data = data
        self.next = None
 
 
class CircularLinkedList:
    def __init__(self):
        self.head = None
        self.last_node = None
 
    # function to add elements to circular linked list
    def append(self, data):
        # is circular linked list is empty then last_node will be none so in if condition head will be created
        if self.last_node is None:
            self.head = Node(data)
            self.last_node = self.head
        # adding node to the tail of circular linked list
        else:
            self.last_node.next = Node(data)
            self.last_node = self.last_node.next
            self.last_node.next = self.head
 
    # function to print the content of circular linked list
    def display(self):
        current = self.head
        while current is not None:
            print(current.data, end=' ')
            current = current.next
            if current == self.head:
                break
        print()
 
 
if __name__ == '__main__':
    L = CircularLinkedList()
    L.append(1)
    L.append(2)
    L.append(3)
    L.append(4)
    L.display()

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;
};

Python3




# structure of Node
class Node:
    def __init__(self, data):
        self.previous = None
        self.data = data
        self.next = 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;
}

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

Python3




# structure of Node
class Node:
    def __init__(self, data):
        self.previous = None
        self.data = data
        self.next = None
 
 
class DoublyLinkedList:
    def __init__(self):
        self.head = None
        self.start_node = None
        self.last_node = None
 
    # function to add elements to doubly linked list
    def append(self, data):
        # is doubly linked list is empty then last_node will be none so in if condition head will be created
        if self.last_node is None:
            self.head = Node(data)
            self.last_node = self.head
        # adding node to the tail of doubly linked list
        else:
            new_node = Node(data)
            self.last_node.next = new_node
            new_node.previous = self.last_node
            new_node.next = self.head
            self.last_node = new_node
 
    # function to print the content of doubly linked list
    def display(self, Type = 'Left_To_Right'):
        if Type == 'Left_To_Right':
            current = self.head
            while current.next is not None:
                print(current.data, end=' ')
                current = current.next
                if current == self.head:
                    break
            print()
        else:
            current = self.last_node
            while current.previous is not None:
                print(current.data, end=' ')
                current = current.previous
                if current == self.last_node.next:
                    print(self.last_node.next.data, end=' ')
                    break
            print()
 
 
if __name__ == '__main__':
    L = DoublyLinkedList()
    L.append(1)
    L.append(2)
    L.append(3)
    L.append(4)
    L.display('Left_To_Right')
    L.display('Right_To_Left')

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
  • 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;
};

Python3




# structure of Node
class Node:
    def __init__(self, data):
        self.data = data
        self.next = 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;
}

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

Python3




# structure of Node
class Node:
    def __init__(self, data):
        self.data = data
        self.next = None
 
 
class LinkedList:
    def __init__(self):
        self.head = Node(0)
        self.last_node = self.head
 
    # function to add elements to header linked list
    def append(self, data):
        self.last_node.next = Node(data)
        self.last_node = self.last_node.next
 
    # function to print the content of header linked list
    def display(self):
        current = self.head.next
        # traversing the header linked list
        while current is not None:
            # at each node printing its data
            print(current.data, end=' ')
            # giving current next node
            current = current.next
        # print(self.head.data)
        print()
 
 
if __name__ == '__main__':
    L = LinkedList()
    # adding elements to the header linked list
    L.append(1)
    L.append(2)
    L.append(3)
    L.append(4)
    # displaying elements of header linked list
    L.display()

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.




My Personal Notes arrow_drop_up
Recommended Articles
Page :