Basic concepts and nomenclatureEdit
Each record of a linked list is often called an 'element' or 'node'.
The field of each node that contains the address of the next node is usually called the 'next link' or 'next pointer'. The remaining fields are known as the 'data', 'information', 'value', 'cargo', or 'payload' fields.
The 'head' of a list is its first node. The 'tail' of a list may refer either to the rest of the list after the head, or to the last node in the list. In Lisp and some derived languages, the next node may be called the 'cdr' (pronounced could-er) of the list, while the payload of the head node may be called the 'car'.
Singly linked listEdit
Singly linked lists contain nodes which have a data field as well as 'next' field, which points to the next node in line of nodes. Operations that can be performed on singly linked lists include insertion, deletion and traversal.
A singly linked list whose nodes contain two fields: an integer value and a link to the next node
The following code demonstrates how to add a new node with data "value" to the end of a singly linked list:
Doubly linked listEdit
In a 'doubly linked list', each node contains, besides the next-node link, a second link field pointing to the 'previous' node in the sequence. The two links may be called 'forward('s') and 'backwards', or 'next' and 'prev'('previous').
A doubly linked list whose nodes contain three fields: an integer value, the link forward to the next node, and the link backward to the previous node
A technique known as XOR-linking allows a doubly linked list to be implemented using a single link field in each node. However, this technique requires the ability to do bit operations on addresses, and therefore may not be available in some high-level languages.
Many modern operating systems use doubly linked lists to maintain references to active processes, threads, and other dynamic objects.[2] A common strategy for rootkits to evade detection is to unlink themselves from these lists.[3]
Multiply linked listEdit
In a 'multiply linked list', each node contains two or more link fields, each field being used to connect the same set of data records in a different order of same set (e.g., by name, by department, by date of birth, etc.). While doubly linked lists can be seen as special cases of multiply linked list, the fact that the two and more orders are opposite to each other leads to simpler and more efficient algorithms, so they are usually treated as a separate case.
Circular linked listEdit
In the last node of a list, the link field often contains a null reference, a special value is used to indicate the lack of further nodes. A less common convention is to make it point to the first node of the list; in that case, the list is said to be 'circular' or 'circularly linked'; otherwise, it is said to be 'open' or 'linear'. It is a list where the last pointer points to the first node.
In the case of a circular doubly linked list, the first node also points to the last node of the list.
Sentinel nodesEdit
In some implementations an extra 'sentinel' or 'dummy' node may be added before the first data record or after the last one. This convention simplifies and accelerates some list-handling algorithms, by ensuring that all links can be safely dereferenced and that every list (even one that contains no data elements) always has a "first" and "last" node.
Empty listsEdit
An empty list is a list that contains no data records. This is usually the same as saying that it has zero nodes. If sentinel nodes are being used, the list is usually said to be empty when it has only sentinel nodes.
Hash linkingEdit
The link fields need not be physically part of the nodes. If the data records are stored in an array and referenced by their indices, the link field may be stored in a separate array with the same indices as the data records.
List handlesEdit
Since a reference to the first node gives access to the whole list, that reference is often called the 'address', 'pointer', or 'handle' of the list. Algorithms that manipulate linked lists usually get such handles to the input lists and return the handles to the resulting lists. In fact, in the context of such algorithms, the word "list" often means "list handle". In some situations, however, it may be convenient to refer to a list by a handle that consists of two links, pointing to its first and last nodes.
Combining alternativesEdit
The alternatives listed above may be arbitrarily combined in almost every way, so one may have circular doubly linked lists without sentinels, circular singly linked lists with sentinels, etc.
TradeoffsEdit
As with most choices in computer programming and design, no method is well suited to all circumstances. A linked list data structure might work well in one case, but cause problems in another. This is a list of some of the common tradeoffs involving linked list structures.
Linked lists vs. dynamic arraysEdit
A dynamic array is a data structure that allocates all elements contiguously in memory, and keeps a count of the current number of elements. If the space reserved for the dynamic array is exceeded, it is reallocated and (possibly) copied, which is an expensive operation.
Linked lists have several advantages over dynamic arrays. Insertion or deletion of an element at a specific point of a list, assuming that we have indexed a pointer to the node (before the one to be removed, or before the insertion point) already, is a constant-time operation (otherwise without this reference it is O(n)), whereas insertion in a dynamic array at random locations will require moving half of the elements on average, and all the elements in the worst case. While one can "delete" an element from an array in constant time by somehow marking its slot as "vacant", this causes fragmentation that impedes the performance of iteration.
Moreover, arbitrarily many elements may be inserted into a linked list, limited only by the total memory available; while a dynamic array will eventually fill up its underlying array data structure and will have to reallocate—an expensive operation, one that may not even be possible if memory is fragmented, although the cost of reallocation can be averaged over insertions, and the cost of an insertion due to reallocation would still be amortized O(1). This helps with appending elements at the array's end, but inserting into (or removing from) middle positions still carries prohibitive costs due to data moving to maintain contiguity. An array from which many elements are removed may also have to be resized in order to avoid wasting too much space.
On the other hand, dynamic arrays (as well as fixed-size array data structures) allow constant-time random access, while linked lists allow only sequential access to elements. Singly linked lists, in fact, can be easily traversed in only one direction. This makes linked lists unsuitable for applications where it's useful to look up an element by its index quickly, such as heapsort. Sequential access on arrays and dynamic arrays is also faster than on linked lists on many machines, because they have optimal locality of reference and thus make good use of data caching.
Another disadvantage of linked lists is the extra storage needed for references, which often makes them impractical for lists of small data items such as characters or boolean values, because the storage overhead for the links may exceed by a factor of two or more the size of the data. In contrast, a dynamic array requires only the space for the data itself (and a very small amount of control data).[note 1] It can also be slow, and with a naïve allocator, wasteful, to allocate memory separately for each new element, a problem generally solved using memory pools.
Some hybrid solutions try to combine the advantages of the two representations. Unrolled linked lists store several elements in each list node, increasing cache performance while decreasing memory overhead for references. CDR coding does both these as well, by replacing references with the actual data referenced, which extends off the end of the referencing record.
A good example that highlights the pros and cons of using dynamic arrays vs. linked lists is by implementing a program that resolves the Josephus problem. The Josephus problem is an election method that works by having a group of people stand in a circle. Starting at a predetermined person, one may count around the circle n times. Once the nth person is reached, one should remove them from the circle and have the members close the circle. The process is repeated until only one person is left. That person wins the election. This shows the strengths and weaknesses of a linked list vs. a dynamic array, because if the people are viewed as connected nodes in a circular linked list, then it shows how easily the linked list is able to delete nodes (as it only has to rearrange the links to the different nodes). However, the linked list will be poor at finding the next person to remove and will need to search through the list until it finds that person. A dynamic array, on the other hand, will be poor at deleting nodes (or elements) as it cannot remove one node without individually shifting all the elements up the list by one. However, it is exceptionally easy to find the nth person in the circle by directly referencing them by their position in the array.
The list ranking problem concerns the efficient conversion of a linked list representation into an array. Although trivial for a conventional computer, solving this problem by a parallel algorithm is complicated and has been the subject of much research.
A balanced tree has similar memory access patterns and space overhead to a linked list while permitting much more efficient indexing, taking O(log n) time instead of O(n) for a random access. However, insertion and deletion operations are more expensive due to the overhead of tree manipulations to maintain balance. Schemes exist for trees to automatically maintain themselves in a balanced state: AVL trees or red–black trees.
Singly linked linear lists vs. other listsEdit
While doubly linked and circular lists have advantages over singly linked linear lists, linear lists offer some advantages that make them preferable in some situations.
A singly linked linear list is a recursive data structure, because it contains a pointer to a smaller object of the same type. For that reason, many operations on singly linked linear lists (such as merging two lists, or enumerating the elements in reverse order) often have very simple recursive algorithms, much simpler than any solution using iterative commands. While those recursive solutions can be adapted for doubly linked and circularly linked lists, the procedures generally need extra arguments and more complicated base cases.
Linear singly linked lists also allow tail-sharing, the use of a common final portion of sub-list as the terminal portion of two different lists. In particular, if a new node is added at the beginning of a list, the former list remains available as the tail of the new one—a simple example of a persistent data structure. Again, this is not true with the other variants: a node may never belong to two different circular or doubly linked lists.
In particular, end-sentinel nodes can be shared among singly linked non-circular lists. The same end-sentinel node may be used for every such list. In Lisp, for example, every proper list ends with a link to a special node, denoted by nil or (), whose CAR and CDR links point to itself. Thus a Lisp procedure can safely take the CAR or CDR of any list.
The advantages of the fancy variants are often limited to the complexity of the algorithms, not in their efficiency. A circular list, in particular, can usually be emulated by a linear list together with two variables that point to the first and last nodes, at no extra cost.
Doubly linked vs. singly linkedEdit
Double-linked lists require more space per node (unless one uses XOR-linking), and their elementary operations are more expensive; but they are often easier to manipulate because they allow fast and easy sequential access to the list in both directions. In a doubly linked list, one can insert or delete a node in a constant number of operations given only that node's address. To do the same in a singly linked list, one must have the address of the pointer to that node, which is either the handle for the whole list (in case of the first node) or the link field in the previous node. Some algorithms require access in both directions. On the other hand, doubly linked lists do not allow tail-sharing and cannot be used as persistent data structures.
Circularly linked vs. linearly linkedEdit
A circularly linked list may be a natural option to represent arrays that are naturally circular, e.g. the corners of a polygon, a pool of buffers that are used and released in FIFO ("first in, first out") order, or a set of processes that should be time-shared in round-robin order. In these applications, a pointer to any node serves as a handle to the whole list.
With a circular list, a pointer to the last node gives easy access also to the first node, by following one link. Thus, in applications that require access to both ends of the list (e.g., in the implementation of a queue), a circular structure allows one to handle the structure by a single pointer, instead of two.
A circular list can be split into two circular lists, in constant time, by giving the addresses of the last node of each piece. The operation consists in swapping the contents of the link fields of those two nodes. Applying the same operation to any two nodes in two distinct lists joins the two list into one. This property greatly simplifies some algorithms and data structures, such as the quad-edge and face-edge.
The simplest representation for an empty circular list (when such a thing makes sense) is a null pointer, indicating that the list has no nodes. Without this choice, many algorithms have to test for this special case, and handle it separately. By contrast, the use of null to denote an empty linear list is more natural and often creates fewer special cases.
For some applications, it can be useful to use singly linked lists that can vary between being circular and being linear, or even circular with a linear initial segment. Algorithms for searching or otherwise operating on these have to take precautions to avoid accidentally entering an endless loop. One usual method is to have a second pointer walking the list at half or double the speed, and if both pointers meet at the same node, you know you found a cycle.
Using sentinel nodesEdit
Sentinel node may simplify certain list operations, by ensuring that the next or previous nodes exist for every element, and that even empty lists have at least one node. One may also use a sentinel node at the end of the list, with an appropriate data field, to eliminate some end-of-list tests. For example, when scanning the list looking for a node with a given value x, setting the sentinel's data field to x makes it unnecessary to test for end-of-list inside the loop. Another example is the merging two sorted lists: if their sentinels have data fields set to +∞, the choice of the next output node does not need special handling for empty lists.
However, sentinel nodes use up extra space (especially in applications that use many short lists), and they may complicate other operations (such as the creation of a new empty list).
However, if the circular list is used merely to simulate a linear list, one may avoid some of this complexity by adding a single sentinel node to every list, between the last and the first data nodes. With this convention, an empty list consists of the sentinel node alone, pointing to itself via the next-node link. The list handle should then be a pointer to the last data node, before the sentinel, if the list is not empty; or to the sentinel itself, if the list is empty.
The same trick can be used to simplify the handling of a doubly linked linear list, by turning it into a circular doubly linked list with a single sentinel node. However, in this case, the handle should be a single pointer to the dummy node itself.[8]
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:
// Node of a doubly linked list
class Node {
public:
int data;
// Pointer to next node in LL
Node* next;
};
|
// 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
|
# structure of Node
class Node:
def __init__(self, data):
self.data = data
self.next = None
|
// Structure of Node
public class Node
{
public int data;
// Pointer to next node in LL
public Node next;
};
//this code is contributed by shivanisinghss2110
|
// 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++ 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 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# 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
|
# 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()
|
<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>
|
- 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:
// 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;
};
|
// 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
|
# structure of Node
class Node:
def __init__(self, data):
self.previous = None
self.data = data
self.next = None
|
// 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++ 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 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
|
# 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# 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
|
- 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:
// Structure for a node
class Node {
public:
int data;
// Pointer to next node in CLL
Node* next;
};
|
// Structure for a node
static class Node
{
int data;
// Pointer to next node in CLL
Node next;
};
// This code is contributed by shivanisinghss2110
|
# structure of Node
class Node:
def __init__(self, data):
self.data = data
self.next = None
|
// Structure for a node
public class Node
{
public int data;
// Pointer to next node in CLL
public Node next;
};
// This code is contributed by shivanisinghss2110
|
- Creation and Traversal of Circular Linked List:
// 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 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
|
# 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# 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
|
- 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:
// 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;
};
|
// Structure of a Node
static class Node
{
int data;
// Pointer to next node in DCLL
Node next;
// Pointer to the previous node in DCLL
Node prev;
};
//this code is contributed by shivanisinghss2110
|
# structure of Node
class Node:
def __init__(self, data):
self.previous = None
self.data = data
self.next = None
|
// Structure of a Node
public class Node
{
public int data;
// Pointer to next node in DCLL
public Node next;
// Pointer to the previous node in DCLL
public Node prev;
};
// This code is contributed by shivanisinghss2110
|
- Creation and Traversal of Doubly Circular Linked List:
// 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 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
|
# 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# 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
|
- 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:
// Structure of the list
struct link {
int info;
// Pointer to the next node
struct link* next;
};
|
# structure of Node
class Node:
def __init__(self, data):
self.data = data
self.next = None
|
// Structure of the list
static class link {
int info;
// Pointer to the next node
link next;
};
// this code is contributed by shivanisinghss2110
|
// Structure of the list
public class link {
public int info;
// Pointer to the next node
public link next;
};
// this code is contributed by shivanisinghss2110
|
- Creation and Traversal of Header Linked List:
// 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 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
|
# 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# 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
|
Linked List MCQ : Operations on Linked List (Multiple Choice Questions)
admin2013-06-02T03:31:15+00:00ITE6201 Data Structures and Algorithms
(PreLim)
Question1
Question text
The operation of processing each element in the list is known as ________________.
inserting
traversal
merging
sorting
Question2
Question text
This form of access is used to add/remove nodes from a stack.
None of these
FIFO
Both of these
LIFO
Question3
Question text
Indexing the ________________ element in the list is not possible in linked lists.
last
middle
first
anywhere in between
Question4
Question text
This indicates the end of the list.
Last pointer
Guard
Sentinel
End pointer
Question5
Question text
In linked representation of stack, ___________ fields hold the elements of the stack.
LINK
INFO
TOP
NULL
Question6
Question text
Stack follows the strategy of ________________.
FIFO
LIFO
LRU
RANDOM
Question7
Question text
In the linked representation of the stack, __________ pointer behaves as the top pointer variable of stack.
Begin
Avail
Start
Stop
Question8
Question text
This form of access is used to add and remove nodes from a queue.
None of these
LIFO, Last In First Out
Both of these
FIFO, First In First Out
Question9
Question text
LINK is the pointer pointing to the ____________________.
predecessor node
successor node
head node
last node
Question10
Question text
This may take place only when there is some minimum amount or no space left in free storage list.
Recycle bin
Maintenance
Memory management
Garbage collection
Question11
Question text
Each node in a linked list must contain at least ___________________.
Three fields
Five fields
Two fields
Four fields
Question12
Question text
Value of first linked list index is _______________.
-1
0
1
2
Question13
Question text
Which is the pointer associated with the availability list?
FIRST
REAR
TOP
AVAIL
Question14
Question text
New nodes are added to the ________ of the queue.
Middle
Front
Back
Front and Back
Question15
Question text
A linear list in which the pointer points only to the successive node.
singly linked list
circular linked list
doubly linked list
none of these
Question16
Question text
The retrieval of items in a stack is ___________ operation.
push
retrieval
access
pop
Question17
Question text
The situation when in a linked list START=NULL is ____________________.
Overflow
Houseful
Underflow
Saturated
Question18
Question text
This is the term used to delete an element from the stack.
Pull
Pop
Pump
Push
Question19
Question text
Each node in singly linked list has _______ fields.
4
1
3
2
Question20
Question text
A linear list in which the last node points to the first node.
none of these
circular linked list
singly linked list
doubly linked list
Question21
Question text
Linked lists are best suited _____________________.
for the size of the structure and the data in the structure are constantly changing
data structure
for relatively permanent collections of data
for none of these situations
Question22
Question text
The dummy header in linked list contains ____________________.
first record of the actual data
middle record of the actual data
last record of the actual data
pointer to the last record of the actual data
Question23
Question text
The term used to insert an element into stack.
pump
pop
pull
push
Question24
Question text
In linked representation of stack, the null pointer of the last node in the list signals _____________________.
Bottom of the stack
Middle of the stack
In between some value
Beginning of the stack
Question25
Question text
What is a run list?
small batches of records from a file
number of files in external storage
number of elements having same value
number of records
Question26
Question text
The elements are removal from a stack in _________ order.
Sequential
Reverse
Hierarchical
Alternative
Question27
Question text
A pointer variable which contains the location at the top element of the stack.
Top
Final
End
Last
Question28
Question text
In linked lists, there are no NULL links in ______________
single linked list
linear doubly linked list
linked list
circular linked list
Question29
Question text
Which is the pointer associated with the stack?
FRONT
FIRST
TOP
REAR
Question30
Question text
Which of the following is an application of stack?
infix to postfix
all of these
finding factorial
tower of Hanoi
Question1
Question text
This is the term used to delete an element from the stack.
Pump
Pull
Push
Pop
Question2
Question text
Linked lists are best suited _____________________.
data structure
for the size of the structure and the data in the structure are constantly changing
for relatively permanent collections of data
for none of these situations
Question3
Question text
Stack follows the strategy of ________________.
LIFO
RANDOM
LRU
FIFO
Question4
Question text
A linear list in which the last node points to the first node.
singly linked list
none of these
circular linked list
doubly linked list
Question5
Question text
In the linked representation of the stack, __________ pointer behaves as the top pointer variable of stack.
Avail
Start
Stop
Begin
Question6
Question text
This is the insertion operation in the stack.
pop
top
insert
push
Question7
Question text
Which of the following is an application of stack?
finding factorial
tower of Hanoi
infix to postfix
all of these
Question8
Question text
Which of the following is two way lists?
Linked list with header and trailer nodes
List traversed in two directions
Grounded header list
Circular header list
Question9
Question text
Each node in a linked list must contain at least ___________________.
Four fields
Two fields
Three fields
Five fields
Question10
Question text
What is a queue?
FILO
LIFO
LOFI
FIFO
Question11
Question text
This is a linear list in which insertions and deletions are made to form either end of the structure.
Random of queue
Circular queue
Priority
Dequeue
Question12
Question text
What happens when you push a new node onto a stack?
The new node is placed at the back of the linked list
The new node is placed at the front of the linked list
No changes happen
The new node is placed at the middle of the linked list
Question13
Question text
The situation when in a linked list START=NULL is ____________________.
Underflow
Saturated
Overflow
Houseful
Question14
Question text
In linked representation of stack, the null pointer of the last node in the list signals _____________________.
Bottom of the stack
Middle of the stack
Beginning of the stack
In between some value
Question15
Question text
The elements are removal from a stack in _________ order.
Alternative
Hierarchical
Reverse
Sequential
Question16
Question text
The term used to insert an element into stack.
pop
pull
pump
push
Question17
Question text
Value of first linked list index is _______________.
2
0
-1
1
Question18
Question text
A linear list in which the pointer points only to the successive node.
circular linked list
singly linked list
none of these
doubly linked list
Question19
Question text
The termpushandpopis related to _____________.
lists
trees
stacks
array
Question20
Question text
In a linked list, the ____________ contains the address of next element in the list.
Start field
Next element field
Link field
Info field
Question21
Question text
The dummy header in linked list contains ____________________.
first record of the actual data
last record of the actual data
middle record of the actual data
pointer to the last record of the actual data
Question22
Question text
Which of the following names does not relate to stacks?
FIFO lists
LIFO lists
Piles
Push down lists
Question23
Question text
The retrieval of items in a stack is ___________ operation.
push
retrieval
access
pop
Question24
Question text
Which is the pointer associated with the availability list?
TOP
AVAIL
REAR
FIRST
Question25
Question text
Which is the pointer associated with the stack?
TOP
FIRST
FRONT
REAR
Question26
Question text
The operation of processing each element in the list is known as ________________.
merging
inserting
traversal
sorting
Question27
Question text
In linked lists, there are no NULL links in ______________
single linked list
circular linked list
linked list
linear doubly linked list
Question28
Question text
New nodes are added to the ________ of the queue.
Front and Back
Middle
Front
Back
Question29
Question text
This form of access is used to add and remove nodes from a queue.
None of these
LIFO, Last In First Out
FIFO, First In First Out
Both of these
Question30
Question text
Each node in singly linked list has _______ fields.
1
3
2
4
Types of Linked List and Operation on Linked List
In the previous blog, we have seen the structure and properties of a Linked List. In this blog, we will discuss the types of a linked list and basic operations that can be performed on a linked list.
Types of Linked List
Following are the types of linked list
- Singly Linked List.
- Doubly Linked List.
- Circular Linked List.
Singly Linked List
A Singly-linked list is a collection of nodes linked together in a sequential way where each node of the singly linked list contains a data field and an address field that contains the reference of the next node.
The structure of the node in the Singly Linked List is
The nodes are connected to each other in this form where the value of the next variable of the last node is NULL i.e. next = NULL, which indicates the end of the linked list.
Doubly Linked List
A Doubly Linked List contains an extra memory to store the address of the previous node, together with the address of the next node and data which are there in the singly linked list. So, here we are storing the address of the next as well as the previous nodes.
The following is the structure of the node in the Doubly Linked List(DLL):
The nodes are connected to each other in this form where the first node has prev = NULL and the last node has next = NULL.
Advantages over Singly Linked List-
- It can be traversed both forward and backward direction.
- The delete operation is more efficient if the node to be deleted is given. (Think! you will get the answer in the second half of this blog)
- The insert operation is more efficient if the node is given before which insertion should take place. (Think!)
Disadvantages over Singly Linked List-
- It will require more space as each node has an extra memory to store the address of the previous node.
- The number of modification increase while doing various operations like insertion, deletion, etc.
Circular Linked List
A circular linked list is either a singly or doubly linked list in which there are no NULL values. Here, we can implement the Circular Linked List by making the use of Singly or Doubly Linked List. In the case of a singly linked list, the next of the last node contains the address of the first node and in case of a doubly-linked list, the next of last node contains the address of the first node and prev of the first node contains the address of the last node.
Advantages of a Circular linked list
- The list can be traversed from any node.
- Circular lists are the required data structure when we want a list to be accessed in a circle or loop.
- We can easily traverse to its previous node in a circular linked list, which is not possible in a singly linked list. (Think!)
Disadvantages of Circular linked list
- If not traversed carefully, then we could end up in an infinite loop because here we don't have any NULL value to stop the traversal.
- Operations in a circular linked list are complex as compared to a singly linked list and doubly linked list like reversing a circular linked list, etc.
Basic Operations on Linked List
- Traversal: To traverse all the nodes one after another.
- Insertion: To add a node at the given position.
- Deletion: To delete a node.
- Searching: To search an element(s) by value.
- Updating: To update a node.
- Sorting: To arrange nodes in a linked list in a specific order.
- Merging: To merge two linked lists into one.
We will see the various implementation of these operations on a singly linked list.
Following is the structure of the node in a linked list:
class Node{ int data // variable containing the data of the node Node next // variable containing the address of next node }Linked List Traversal
The idea here is to step through the list from beginning to end. For example, we may want to print the list or search for a specific node in the list.
The algorithm for traversing a list
- Start with the head of the list. Access the content of the head node if it is not null.
- Then go to the next node(if exists) and access the node information
- Continue until no more nodes (that is, you have reached the null node)
Linked List node Insertion
There can be three cases that will occur when we are inserting a node in a linked list.
- Insertion at the beginning
- Insertion at the end. (Append)
- Insertion after a given node
Insertion at the beginning
Since there is no need to find the end of the list. If the list is empty, we make the new node as the head of the list. Otherwise, we we have to connect the new node to the current head of the list and make the new node, the head of the list.
Insertion at end
We will traverse the list until we find the last node. Then we insert the new node to the end of the list. Note that we have to consider special cases such as list being empty.
In case of a list being empty, we will return the updated head of the linked list because in this case, the inserted node is the first as well as the last node of the linked list.
Insertion after a given node
We are given the reference to a node, and the new node is inserted after the given node.
NOTE: If the address of the prevNode is not given, then you can traverse to that node by finding the data value.
Linked List node Deletion
To delete a node from a linked list, we need to do these steps
- Find the previous node of the node to be deleted.
- Change the next pointer of the previous node
- Free the memory of the deleted node.
In the deletion, there is a special case in which the first node is deleted. In this, we need to update the head of the linked list.
Linked List node Searching
To search any value in the linked list, we can traverse the linked list and compares the value present in the node.
bool searchLL(Node head, int val) { Node temp = head // creating a temp variable pointing to the head of the linked list while( temp != NULL) // traversing the list { if( temp.data == val ) return true temp = temp.next } return false }Linked List node Updation
To update the value of the node, we just need to set the data part to the new value.
Below is the implementation in which we had to update the value of the first node in which data is equal to val and we have to set it to newVal.
void updateLL(Node head, int val, int newVal) { Node temp = head while(temp != NULL) { if( temp.data == val) { temp.data = newVal return } temp = temp.next } }Suggested Problems to solve in Linked List
- Reverse linked list
- Middle of the Linked List
- Odd even linked List
- Remove Duplicates from Sorted List
- Merge Sort on Linked List
- Check if a singly linked list is a palindrome
- Detect and Remove Loop in a Linked List
- Sort a linked list using insertion sort
- Remove Nth Node from List End
Happy coding! Enjoy Algorithms.