Linked List | Set 1 (Introduction)

06 Jul, 2022
Like arrays, Linked List is a linear data structure. Unlike arrays, linked list elements are not stored at a contiguous location; the elements are linked using pointers. They includes a series of connected nodes. Here, each node stores the data and the address of the next node. 
Arrays can be used to store linear data of similar types, but arrays have the following limitations. 
The size of the arrays is fixed: So we must know the upper limit on the number of elements in advance. Also, generally, the allocated memory is equal to the upper limit irrespective of the usage. 
Insertion of a new element / Deletion of a existing element in an array of elements is expensive: The room has to be created for the new elements and to create room existing elements have to be shifted but in Linked list if we have the head node then we can traverse to any node through it and insert new node at the required position.
For example, in a system, if we maintain a sorted list of IDs in an array id[]. id[] = [1000, 1010, 1050, 2000, 2040]. And if we want to insert a new ID 1005, then to maintain the sorted order, we have to move all the elements after 1000 (excluding 1000). Deletion is also expensive with arrays until unless some special techniques are used. For example, to delete 1010 in id[], everything after 1010 has to be moved due to this so much work is being done which affects the efficiency of the code.
Dynamic Array.Ease of Insertion/Deletion.
Dynamic Array.
Ease of Insertion/Deletion.
Random access is not allowed. We have to access elements sequentially starting from the first node(head node). So we cannot do binary search with linked lists efficiently with its default implementation. Read about it here. Extra memory space for a pointer is required with each element of the list. Not cache friendly. Since array elements are contiguous locations, there is locality of reference which is not there in case of linked lists.
Random access is not allowed. We have to access elements sequentially starting from the first node(head node). So we cannot do binary search with linked lists efficiently with its default implementation. Read about it here. 
Extra memory space for a pointer is required with each element of the list. 
Not cache friendly. Since array elements are contiguous locations, there is locality of reference which is not there in case of linked lists.
Chapters
descriptions off, selected
captions settings, opens captions settings dialog
captions off, selected
English
This is a modal window.
Beginning of dialog window. Escape will cancel and close the window.
End of dialog window.
A linked list is represented by a pointer to the first node of the linked list. The first node is called the head. If the linked list is empty, then the value of the head points to NULL. 
Each node in a list consists of at least two parts: 
A Data Item (we can store integer, strings or any type of data).Pointer (Or Reference) to the next node (connects one node to another) or An address of another node
A Data Item (we can store integer, strings or any type of data).
Pointer (Or Reference) to the next node (connects one node to another) or An address of another node
In C, we can represent a node using structures. Below is an example of a linked list node with integer data. In Java or C#, LinkedList can be represented as a class and a Node as a separate class. The LinkedList class contains a reference of Node class type.  
C
C++
Java
Python
C#
Javascript
// A linked list nodestruct Node {    int data;    struct Node* next;};
class Node {public:    int data;    Node* next;};
class LinkedList {    Node head; // head of the list      /* Linked list Node*/    class Node {        int data;        Node next;          // Constructor to create a new node        // Next is by default initialized        // as null        Node(int d) {           data = d;          next = null;        }    }}
# Node classclass Node:       # Function to initialize the node object    def __init__(self, data):        self.data = data  # Assign data        self.next = None  # Initialize                           # next as null   # Linked List classclass LinkedList:         # Function to initialize the Linked     # List object    def __init__(self):         self.head = None
class LinkedList {    // The first node(head) of the linked list    // Will be an object of type Node (null by default)    Node head;      class Node {        int data;        Node next;          // Constructor to create a new node        Node(int d) { data = d; }    }}
<script>var head; // head of the list  /* Linked list Node*/    class Node     {               // Constructor to create a new node        // Next is by default initialized        // as null        constructor(val) {            this.data = val;            this.next = null;        }    }  // This code is contributed by gauravrajput1</script>
Let us create a simple linked list with 3 nodes. 
C++
C
Java
Python
C#
Javascript
// A simple CPP program to introduce// a linked list#include <bits/stdc++.h>using namespace std;  class Node {public:    int data;    Node* next;};  // Program to create a simple linked// list with 3 nodesint 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();      /* Three blocks have been allocated dynamically.     We have pointers to these three blocks as head,     second and third         head         second         third         |             |             |         |             |             |     +---+-----+     +----+----+     +----+----+     | # | # |     | # | # |     | # | # |     +---+-----+     +----+----+     +----+----+       # represents any random value. Data is random because we haven’t assigned anything yet */      head->data = 1; // assign data in first node    head->next = second; // Link first node with    // the second node      /* data has been assigned to the data part of first     block (block pointed by the head). And next     pointer of the first block points to second.     So they both are linked.       head         second         third         |             |             |         |             |             |     +---+---+     +----+----+     +-----+----+     | 1 | o----->| # | # |     | # | # |     +---+---+     +----+----+     +-----+----+     */      // assign data to second node    second->data = 2;      // Link second node with the third node    second->next = third;      /* data has been assigned to the data part of the second     block (block pointed by second). And next     pointer of the second block points to the third     block. So all three blocks are linked.           head         second         third         |             |             |         |             |             |     +---+---+     +---+---+     +----+----+     | 1 | o----->| 2 | o-----> | # | # |     +---+---+     +---+---+     +----+----+     */      third->data = 3; // assign data to third node    third->next = NULL;      /* data has been assigned to the data part of the third     block (block pointed by third). And next pointer     of the third block is made NULL to indicate     that the linked list is terminated here.       We have the linked list ready.           head                 |             |         +---+---+     +---+---+     +----+------+         | 1 | o----->| 2 | o-----> | 3 | NULL |         +---+---+     +---+---+     +----+------+                     Note that only the head is sufficient to represent     the whole list. We can traverse the complete     list by following the next pointers. */      return 0;}  // This code is contributed by rathbhupendra
// A simple C program to introduce// a linked list#include <stdio.h>#include <stdlib.h>  struct Node {    int data;    struct Node* next;};  // Program to create a simple linked// list with 3 nodesint main(){    struct Node* head = NULL;    struct Node* second = NULL;    struct Node* third = NULL;      // allocate 3 nodes in the heap    head = (struct Node*)malloc(sizeof(struct Node));    second = (struct Node*)malloc(sizeof(struct Node));    third = (struct Node*)malloc(sizeof(struct Node));      /* Three blocks have been allocated dynamically.      We have pointers to these three blocks as head,     second and third            head           second           third        |                |               |        |                |               |    +---+-----+     +----+----+     +----+----+    | #  | #  |     | #  | #  |     |  # |  # |    +---+-----+     +----+----+     +----+----+        # represents any random value.   Data is random because we haven’t assigned    anything yet  */      head->data = 1; // assign data in first node    head->next = second; // Link first node with    // the second node      /* data has been assigned to the data part of the first     block (block pointed by the head). And next     pointer of first block points to second.       So they both are linked.         head          second         third        |              |              |        |              |              |    +---+---+     +----+----+     +-----+----+    | 1  | o----->| #  | #  |     |  #  | #  |    +---+---+     +----+----+     +-----+----+      */      // assign data to second node    second->data = 2;      // Link second node with the third node    second->next = third;      /* data has been assigned to the data part of the second     block (block pointed by second). And next     pointer of the second block points to the third      block. So all three blocks are linked.           head         second         third        |             |             |        |             |             |    +---+---+     +---+---+     +----+----+    | 1  | o----->| 2 | o-----> |  # |  # |    +---+---+     +---+---+     +----+----+      */      third->data = 3; // assign data to third node    third->next = NULL;      /* data has been assigned to data part of third    block (block pointed by third). And next pointer    of the third block is made NULL to indicate    that the linked list is terminated here.       We have the linked list ready.               head                 |             |         +---+---+     +---+---+       +----+------+        | 1  | o----->|  2  | o-----> |  3 | NULL |        +---+---+     +---+---+       +----+------+                      Note that only head is sufficient to represent     the whole list.  We can traverse the complete     list by following next pointers.    */      return 0;}
// A simple Java program to introduce a linked listclass LinkedList {    Node head; // head of list      /* Linked list Node.  This inner class is made static so that       main() can access it */    static class Node {        int data;        Node next;        Node(int d)        {            data = d;            next = null;        } // Constructor    }      /* method to create a simple linked list with 3 nodes*/    public static void main(String[] args)    {        /* Start with the empty list. */        LinkedList llist = new LinkedList();          llist.head = new Node(1);        Node second = new Node(2);        Node third = new Node(3);          /* Three nodes have been allocated dynamically.          We have references to these three blocks as head,            second and third            llist.head        second              third             |                |                  |             |                |                  |         +----+------+     +----+------+     +----+------+         | 1  | null |     | 2  | null |     |  3 | null |         +----+------+     +----+------+     +----+------+ */          llist.head.next = second; // Link first node with the second node          /*  Now next of the first Node refers to the second.  So they            both are linked.           llist.head        second              third            |                |                  |            |                |                  |        +----+------+     +----+------+     +----+------+        | 1  |  o-------->| 2  | null |     |  3 | null |        +----+------+     +----+------+     +----+------+ */          second.next = third; // Link second node with the third node          /*  Now next of the second Node refers to third.  So all three            nodes are linked.           llist.head        second              third            |                |                  |            |                |                  |        +----+------+     +----+------+     +----+------+        | 1  |  o-------->| 2  |  o-------->|  3 | null |        +----+------+     +----+------+     +----+------+ */    }}
# A simple Python program to introduce a linked list  # Node classclass Node:      # Function to initialise the node object    def __init__(self, data):        self.data = data  # Assign data        self.next = None  # Initialize next as null    # Linked List class contains a Node objectclass LinkedList:      # Function to initialize head    def __init__(self):        self.head = None    # Code execution starts hereif __name__=='__main__':      # Start with the empty list    llist = LinkedList()      llist.head = Node(1)    second = Node(2)    third = Node(3)      '''    Three nodes have been created.    We have references to these three blocks as head,    second and third      llist.head        second              third         |                |                  |         |                |                  |    +----+------+     +----+------+     +----+------+    | 1  | None |     | 2  | None |     |  3 | None |    +----+------+     +----+------+     +----+------+    '''      llist.head.next = second; # Link first node with second       '''    Now next of first Node refers to second.  So they    both are linked.      llist.head        second              third         |                |                  |         |                |                  |    +----+------+     +----+------+     +----+------+    | 1  |  o-------->| 2  | null |     |  3 | null |    +----+------+     +----+------+     +----+------+     '''      second.next = third; # Link second node with the third node      '''    Now next of second Node refers to third.  So all three    nodes are linked.      llist.head        second              third         |                |                  |         |                |                  |    +----+------+     +----+------+     +----+------+    | 1  |  o-------->| 2  |  o-------->|  3 | null |    +----+------+     +----+------+     +----+------+     '''
// A simple C# program to introduce a linked listusing System;  public class LinkedList {    Node head; // head of list      /* Linked list Node. This inner class is made static so that     main() can access it */    public class Node {        public int data;        public Node next;        public Node(int d)        {            data = d;            next = null;        } // Constructor    }      /* method to create a simple linked list with 3 nodes*/    public static void Main(String[] args)    {        /* Start with the empty list. */        LinkedList llist = new LinkedList();          llist.head = new Node(1);        Node second = new Node(2);        Node third = new Node(3);          /* Three nodes have been allocated dynamically.         We have references to these three blocks as head,         second and third           llist.head     second             third             |             |                 |             |             |                 |         +----+------+     +----+------+     +----+------+         | 1 | null |     | 2 | null |     | 3 | null |         +----+------+     +----+------+     +----+------+ */          llist.head.next = second; // Link first node with the second node          /* Now next of first Node refers to second. So they             both are linked.           llist.head     second             third             |             |                 |             |             |                 |         +----+------+     +----+------+     +----+------+         | 1 | o-------->| 2 | null |     | 3 | null |         +----+------+     +----+------+     +----+------+ */          second.next = third; // Link second node with the third node          /* Now next of the second Node refers to third. So all three             nodes are linked.           llist.head     second             third             |             |                 |             |             |                 |         +----+------+     +----+------+     +----+------+         | 1 | o-------->| 2 | o-------->| 3 | null |         +----+------+     +----+------+     +----+------+ */    }}  // This code has been contributed by 29AjayKumar
<script>// A simple javascript program to introduce a linked list      var head; // head of list      /* Linked list Node.  This inner class is made  so that       main() can access it */     class Node {        constructor(d)        {            this.data = d;            this.next = null;        } // Constructor    }      /* method to create a simple linked list with 3 nodes*/                var head = new Node(1);        var second = new Node(2);        var third = new Node(3);          /* Three nodes have been allocated dynamically.          We have references to these three blocks as head,            second and third            llist.head        second              third             |                |                  |             |                |                  |         +----+------+     +----+------+     +----+------+         | 1  | null |     | 2  | null |     |  3 | null |         +----+------+     +----+------+     +----+------+ */          head.next = second; // Link first node with the second node          /*  Now next of the first Node refers to the second.  So they            both are linked.           llist.head        second              third            |                |                  |            |                |                  |        +----+------+     +----+------+     +----+------+        | 1  |  o-------->| 2  | null |     |  3 | null |        +----+------+     +----+------+     +----+------+ */          second.next = third; // Link second node with the third node          /*  Now next of the second Node refers to third.  So all three            nodes are linked.           llist.head        second              third            |                |                  |            |                |                  |        +----+------+     +----+------+     +----+------+        | 1  |  o-------->| 2  |  o-------->|  3 | null |        +----+------+     +----+------+     +----+------+ */   // This code is contributed by umadevi9616 </script>
Linked List Traversal In the previous program, we have created a simple linked list with three nodes. Let us traverse the created list and print the data of each node. For traversal, let us write a general-purpose function printList() that prints any given list. 
 
C++
C
Java
Python3
C#
Javascript
// A simple C++ program for traversal of a linked list#include <bits/stdc++.h>using namespace std;  class Node {public:    int data;    Node* next;};  // This function prints contents of linked list// starting from the given nodevoid printList(Node* n){    while (n != NULL) {        cout << n->data << " ";        n = n->next;    }}  // Driver codeint 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();      head->data = 1; // assign data in first node    head->next = second; // Link first node with second      second->data = 2; // assign data to second node    second->next = third;      third->data = 3; // assign data to third node    third->next = NULL;      printList(head);      return 0;}  // This is code is contributed by rathbhupendra
// A simple C program for traversal of a linked list#include <stdio.h>#include <stdlib.h>  struct Node {    int data;    struct Node* next;};  // This function prints contents of linked list starting from// the given nodevoid printList(struct Node* n){    while (n != NULL) {        printf(" %d ", n->data);        n = n->next;    }}  int main(){    struct Node* head = NULL;    struct Node* second = NULL;    struct Node* third = NULL;      // allocate 3 nodes in the heap    head = (struct Node*)malloc(sizeof(struct Node));    second = (struct Node*)malloc(sizeof(struct Node));    third = (struct Node*)malloc(sizeof(struct Node));      head->data = 1; // assign data in first node    head->next = second; // Link first node with second      second->data = 2; // assign data to second node    second->next = third;      third->data = 3; // assign data to third node    third->next = NULL;      printList(head);      return 0;}
// A simple Java program for traversal of a linked listclass LinkedList {    Node head; // head of list      /* Linked list Node.  This inner class is made static so that       main() can access it */    static class Node {        int data;        Node next;        Node(int d)        {            this.data = d;            next = null;        } // Constructor    }      /* This function prints contents of linked list starting from head */    public void printList()    {        Node n = head;        while (n != null) {            System.out.print(n.data + " ");            n = n.next;        }    }      /* method to create a simple linked list with 3 nodes*/    public static void main(String[] args)    {        /* Start with the empty list. */        LinkedList llist = new LinkedList();          llist.head = new Node(1);        Node second = new Node(2);        Node third = new Node(3);          llist.head.next = second; // Link first node with the second node        second.next = third; // Link second node with the third node          llist.printList();    }}
# A simple Python program for traversal of a linked list  # Node classclass Node:      # Function to initialise the node object    def __init__(self, data):        self.data = data  # Assign data        self.next = None  # Initialize next as null    # Linked List class contains a Node objectclass LinkedList:      # Function to initialize head    def __init__(self):        self.head = None      # This function prints contents of linked list    # starting from head    def printList(self):        temp = self.head        while (temp):            print (temp.data)            temp = temp.next    # Code execution starts hereif __name__=='__main__':      # Start with the empty list    llist = LinkedList()      llist.head = Node(1)    second = Node(2)    third = Node(3)      llist.head.next = second; # Link first node with second    second.next = third; # Link second node with the third node      llist.printList()
// A simple C# program for traversal of a linked listusing System;  public class LinkedList {    Node head; // head of list      /* Linked list Node. This inner     class is made static so that    main() can access it */    public class Node {        public int data;        public Node next;        public Node(int d)        {            data = d;            next = null;          } // Constructor    }      /* This function prints contents of     linked list starting from head */    public void printList()    {        Node n = head;        while (n != null) {            Console.Write(n.data + " ");            n = n.next;        }    }      /* method to create a simple linked list with 3 nodes*/    public static void Main(String[] args)    {        /* Start with the empty list. */        LinkedList llist = new LinkedList();          llist.head = new Node(1);        Node second = new Node(2);        Node third = new Node(3);          llist.head.next = second; // Link first node with the second node        second.next = third; // Link second node with the third node          llist.printList();    }}  /* This code contributed by PrinciRaj1992 */
<script>// A simple javascript program for traversal of a linked list    var head; // head of list      /* Linked list Node.  This inner class is made  so that       main() can access it */    class Node {        constructor(val) {            this.data = val;            this.next = null;        }    }      /* This function prints contents of linked list starting from head */     function printList()    {        var n = head;        while (n != null) {            document.write(n.data + " ");            n = n.next;        }    }      /* method to create a simple linked list with 3 nodes*/                    /* Start with the empty list. */                 var head = new Node(1);        var second = new Node(2);        var third = new Node(3);          head.next = second; // Link first node with the second node        second.next = third; // Link second node with the third node          printList();    // This code contributed by gauravrajput1 </script>
Output: 
 1  2  3
 
ashwani khemani
tobamaestro
princiraj1992
rathbhupendra
29AjayKumar
NikhilKoyikkamannil
Royalcoder
rakshitparashar1
prakashprakhar2021
sahilkansal09
GauravRajput1
adityarajawasthi1602
umadevi9616
ashragautam25
Python-Data-Structures
Linked List
Linked List
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.