What is the difference between a standard and a circular linked list?

Circular Linked List | Set 1 (Introduction and Applications)

We have discussed singly and doubly linked lists in the following posts.

Introduction to Linked List & Insertion
Doubly Linked List Introduction and Insertion

Circular linked list is a linked list where all nodes are connected to form a circle. There is no NULL at the end. A circular linked list can be a singly circular linked list or doubly circular linked list.

Advantages of Circular Linked Lists:
1) Any node can be a starting point. We can traverse the whole list by starting from any point. We just need to stop when the first visited node is visited again.

2) Useful for implementation of queue. Unlike this implementation, we don’t need to maintain two pointers for front and rear if we use circular linked list. We can maintain a pointer to the last inserted node and front can always be obtained as next of last.

3) Circular lists are useful in applications to repeatedly go around the list. For example, when multiple applications are running on a PC, it is common for the operating system to put the running applications on a list and then to cycle through them, giving each of them a slice of time to execute, and then making them wait while the CPU is given to another application. It is convenient for the operating system to use a circular list so that when it reaches the end of the list it can cycle around to the front of the list.

4) Circular Doubly Linked Lists are used for implementation of advanced data structures like Fibonacci Heap.

Next Posts :
Circular Linked List | Set 2 (Traversal)
Circular Singly Linked List | Insertion

Please write comments if you find any bug in above code/algorithm, or find other ways to solve the same problem

Article Tags :

Linked List

circular linked list

Practice Tags :

Linked List

circular linked list

Read Full Article

Circular Linked List

Circular Linked List is little more complicated linked data structure. In the circular linked list we can insert elements anywhere in the list whereas in the array we cannot insert element anywhere in the list because it is in the contiguous memory. In the circular linked list the previous element stores the address of the next element and the last element stores the address of the starting element. The elements points to each other in a circular way which forms a circular chain. The circular linked list has a dynamic size which means the memory can be allocated when it is required.

Application of Circular Linked List

The real life application where the circular linked list is used is our Personal Computers, where multiple applications are running. All the running applications are kept in a circular linked list and the OS gives a fixed time slot to all for running. The Operating System keeps on iterating over the linked list until all the applications are completed.
Another example can be Multiplayer games. All the Players are kept in a Circular Linked List and the pointer keeps on moving forward as a player's chance ends.
Circular Linked List can also be used to create Circular Queue. In a Queue we have to keep two pointers, FRONT and REAR in memory all the time, where as in Circular Linked List, only one pointer is required.

Implementing Circular Linked List

Implementing a circular linked list is very easy and almost similar to linear linked list implementation, with the only difference being that, in circular linked list the last Node will have it's next point to the Head of the List. In Linear linked list the last Node simply holds NULL in it's next pointer.

So this will be oue Node class, as we have already studied in the lesson, it will be used to form the List.

class Node { public: int data; //pointer to the next node node* next; node() { data = 0; next = NULL; } node(int x) { data = x; next = NULL; } }

Circular Linked List

Circular Linked List class will be almost same as the Linked List class that we studied in the previous lesson, with a few difference in the implementation of class methods.

class CircularLinkedList { public: node *head; //declaring the functions //function to add Node at front int addAtFront(node *n); //function to check whether Linked list is empty int isEmpty(); //function to add Node at the End of list int addAtEnd(node *n); //function to search a value node* search(int k); //function to delete any Node node* deleteNode(int x); CircularLinkedList() { head = NULL; } }

Insertion at the Beginning

Steps to insert a Node at beginning :

The first Node is the Head for any Linked List.
When a new Linked List is instantiated, it just has the Head, which is Null.
Else, the Head holds the pointer to the fisrt Node of the List.
When we want to add any Node at the front, we must make the head point to it.
And the Next pointer of the newly added Node, must point to the previous Head, whether it be NULL(in case of new List) or the pointer to the first Node of the List.
The previous Head Node is now the second Node of Linked List, because the new Node is added at the front.

int CircularLinkedList :: addAtFront(node *n) { int i = 0; /* If the list is empty */ if(head == NULL) { n->next = head; //making the new Node as Head head = n; i++; } else { n->next = head; //get the Last Node and make its next point to new Node Node* last = getLastNode(); last->next = n; //also make the head point to the new first Node head = n; i++; } //returning the position where Node is added return i; }

Insertion at the End

Steps to insert a Node at the end :

If the Linked List is empty then we simply, add the new Node as the Head of the Linked List.
If the Linked List is not empty then we find the last node, and make it' next to the new Node, and make the next of the Newly added Node point to the Head of the List.

int CircularLinkedList :: addAtEnd(node *n) { //If list is empty if(head == NULL) { //making the new Node as Head head = n; //making the next pointer of the new Node as Null n->next = NULL; } else { //getting the last node node *last = getLastNode(); last->next = n; //making the next pointer of new node point to head n->next = head; } }

Searching for an Element in the List

In searhing we do not have to do much, we just need to traverse like we did while getting the last node, in this case we will also compare the data of the Node. If we get the Node with the same data, we will return it, otherwise we will make our pointer point the next Node, and so on.

node* CircularLinkedList :: search(int x) { node *ptr = head; while(ptr != NULL && ptr->data != x) { //until we reach the end or we find a Node with data x, we keep moving ptr = ptr->next; } return ptr; }

Deleting a Node from the List

Deleting a node can be done in many ways, like we first search the Node with data which we want to delete and then we delete it. In our approach, we will define a method which will take the data to be deleted as argument, will use the search method to locate it and will then remove the Node from the List.

To remove any Node from the list, we need to do the following :

If the Node to be deleted is the first node, then simply set the Next pointer of the Head to point to the next element from the Node to be deleted. And update the next pointer of the Last Node as well.
If the Node is in the middle somewhere, then find the Node before it, and make the Node before it point to the Node next to it.
If the Node is at the end, then remove it and make the new last node point to the head.

node* CircularLinkedList :: deleteNode(int x) { //searching the Node with data x node *n = search(x); node *ptr = head; if(ptr == NULL) { cout << "List is empty"; return NULL; } else if(ptr == n) { ptr->next = n->next; return n; } else { while(ptr->next != n) { ptr = ptr->next; } ptr->next = n->next; return n; } }

← Prev
Next →

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:

node addNode(node head, int value) { node temp, p; // declare two nodes temp and p temp = createNode(); // assume createNode creates a new node with data = 0 and next pointing to NULL. temp->data = value; // add element's value to data part of node if (head == NULL) { head = temp; // when linked list is empty } else { p = head; // assign head to p while (p->next != NULL) { p = p->next; // traverse the list until p is the last node. The last node always points to NULL. } p->next = temp; // Point the previous last node to the new node created. } return head; }

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]

Circular Linked List: Understanding The Fundamentals

Lesson 6 of 54By Simplilearn

Last updated on Sep 19, 20211270

PreviousNext

Tutorial Playlist
Data Structure Tutorial
Overview
Arrays in Data Structures: A Guide With Examples
Lesson - 1
All You Need to Know About Two-Dimensional Arrays
Lesson - 2
All You Need to Know About a Linked List in a Data Structure
Lesson - 3
The Complete Guide to Implement a Singly Linked List
Lesson - 4
The Ultimate Guide to Implement a Doubly Linked List
Lesson - 5
The Fundamentals for Understanding Circular Linked List
Lesson - 6
The Ultimate Guide To Understand The Differences Between Stack And Queue
Lesson - 7
Implementing Stacks in Data Structures
Lesson - 8
Your One-Stop Solution for Stack Implementation Using Array
Lesson - 9
Your One-Stop Solution for Queue Implementation Using Array
Lesson - 10
Your One-Stop Solution to Learn Depth-First Search(DFS) Algorithm From Scratch
Lesson - 11
Your One-Stop Solution for Stack Implementation Using Linked-List
Lesson - 12
The Definitive Guide to Understand Stack vs Heap Memory Allocation
Lesson - 13
All You Need to Know About Linear Search Algorithm
Lesson - 14
All You Need to Know About Breadth-First Search Algorithm
Lesson - 15
A One-Stop Solution for Using Binary Search Trees in Data Structure
Lesson - 16
The Best Tutorial to Understand Trees in Data Structure
Lesson - 17
A Complete Guide to Implement Binary Tree in Data Structure
Lesson - 18
A Holistic Look at Using AVL Trees in Data Structures
Lesson - 19
All You Need to Know About Tree Traversal in Data Structure
Lesson - 20
The Best Guide You’ll Ever Need to Understand B-Tree in Data Structure
Lesson - 21
The Best Guide You'll Ever Need to Understand Spanning Tree in Data Structure
Lesson - 22
The Best and Easiest Way to Understand an Algorithm
Lesson - 23
Your One-Stop Solution to Understand Shell Sort Algorithm
Lesson - 24
Your One-Stop Solution to Quick Sort Algorithm
Lesson - 25
The Most Useful Guide to Learn Selection Sort Algorithm
Lesson - 26
Everything You Need to Know About Radix Sort Algorithm
Lesson - 27
Everything You Need to Know About the Counting Sort Algorithm
Lesson - 28
Everything You Need to Know About the Merge Sort Algorithm
Lesson - 29
Insertion Sort Algorithm: One-Stop Solution That Will Help You Understand Insertion Sort
Lesson - 30
Everything You Need to Know About the Bubble Sort Algorithm
Lesson - 31
The Best Guide You’ll Ever Need to Understand Bucket Sort Algorithm
Lesson - 32
Your One-Stop Solution to Understand Recursive Algorithm in Programming
Lesson - 33
The Definitive Guide to Understanding Greedy Algorithm
Lesson - 34
Your One-Stop Solution to Understand Backtracking Algorithm
Lesson - 35
The Fundamentals of the Bellman-Ford Algorithm
Lesson - 36
Your One-Stop Solution for Graphs in Data Structures
Lesson - 37
The Best Guide to Understand and Implement Solutions for Tower of Hanoi Puzzle
Lesson - 38
A Simplified and Complete Guide to Learn Space and Time Complexity
Lesson - 39
All You Need to Know About the Knapsack Problem : Your Complete Guide
Lesson - 40
The Fibonacci Series: Mathematical and Programming Interpretation
Lesson - 41
The Holistic Look at Longest Common Subsequence Problem
Lesson - 42
The Best Article to Understand What Is Dynamic Programming
Lesson - 43
A Guide to Implement Longest Increasing Subsequence Using Dynamic Programming
Lesson - 44
A Holistic Guide to Learn Stop Solution Using Dynamic Programming
Lesson - 45
One Stop Solution to All the Dynamic Programming Problems
Lesson - 46
Understanding the Fundamentals of Binomial Distribution
Lesson - 47
Here’s All You Need to Know About Minimum Spanning Tree in Data Structures
Lesson - 48
Understanding the Difference Between Array and Linked List
Lesson - 49
The Best Article Out There to Understand the B+ Tree in Data Structure
Lesson - 50
A Comprehensive Look at Queue in Data Structure
Lesson - 51
Your One-Stop Solution to Understand Coin Change Problem
Lesson - 52
The Best Way to Understand the Matrix Chain Multiplication Problem
Lesson - 53
Your One-Stop Solution to Learn Floyd-Warshall Algorithm for Using Dynamic Programming
Lesson - 54

A circular linked list is used to loop your music playlist to implement a circular queue. A circular linked list is a unidirectional linked list; i.e., you can traverse it from head to tail. Unlike other linked lists, its tail points back at the head node. This tutorial will help you understand the fundamental technicalities of circular linked lists with all the necessary details and practical examples.

How to Implement a Circular Linked List?

You can create nodes of circular-linked lists using classes or structures. These nodes are then linked with each other using the next pointer.

Code:

//A c++ program to implement linked list

#include <bits/stdc++.h>

using namespace std;

//A class to create a node

class Node

{

public:

int data;

Node *next;

};

// a function to insert a node at the beginning

void push(Node **head, int data)

{

Node *newnode = new Node();

Node *temp = *head;

newnode->data = data;

newnode->next = *head;

//If linked list is not NULL then

//set the next of last node as newnode

if (*head != NULL)

{

while (temp->next != *head)

temp = temp->next;

temp->next = newnode;

}

else

newnode->next = newnode;

*head = newnode;//change head

}

//A function to print the linked list

void printList(Node *head)

{

Node *temp = head;

if (head != NULL)

{

cout << temp->data << " ";

temp = temp->next;

}

while (temp != head);

}

int main()

{

//we will start with empty list

Node *head = NULL;

// insert 12

push(&head, 12);//12->12

//insert 56

push(&head, 56);//56->12->56

//insert 2

push(&head, 2);//2->56->12->2

//Insert 11

push(&head, 11);//11->2->56->12->11

cout << "Created Linked List: \n ";

printList(head);

return 0;

}

Full Stack Web Developer Course

To become an expert in MEAN StackView Course

1. Introduction

In Computer Science, a linked list is a linear data structure in which a pointer in each element determines the order.

In this tutorial, we’ll show how to check if a linked list is a circular linked list.

Top List List

What is the difference between a standard and a circular linked list?

Circular Linked List | Set 1 (Introduction and Applications)

Circular Linked List

Application of Circular Linked List

Implementing Circular Linked List

Circular Linked List

Insertion at the Beginning

Insertion at the End

Searching for an Element in the List

Deleting a Node from the List

Basic concepts and nomenclatureEdit

Singly linked listEdit

Doubly linked listEdit

Multiply linked listEdit

Circular linked listEdit

Sentinel nodesEdit

Empty listsEdit

Hash linkingEdit

List handlesEdit

Combining alternativesEdit

TradeoffsEdit

Linked lists vs. dynamic arraysEdit

Singly linked linear lists vs. other listsEdit

Doubly linked vs. singly linkedEdit

Circularly linked vs. linearly linkedEdit

Using sentinel nodesEdit

Circular Linked List: Understanding The Fundamentals

Data Structure Tutorial

Arrays in Data Structures: A Guide With Examples

All You Need to Know About Two-Dimensional Arrays

All You Need to Know About a Linked List in a Data Structure

The Complete Guide to Implement a Singly Linked List

The Ultimate Guide to Implement a Doubly Linked List

The Fundamentals for Understanding Circular Linked List

The Ultimate Guide To Understand The Differences Between Stack And Queue

Implementing Stacks in Data Structures

Your One-Stop Solution for Stack Implementation Using Array

Your One-Stop Solution for Queue Implementation Using Array

Your One-Stop Solution to Learn Depth-First Search(DFS) Algorithm From Scratch

Your One-Stop Solution for Stack Implementation Using Linked-List

The Definitive Guide to Understand Stack vs Heap Memory Allocation

All You Need to Know About Linear Search Algorithm

All You Need to Know About Breadth-First Search Algorithm

A One-Stop Solution for Using Binary Search Trees in Data Structure

The Best Tutorial to Understand Trees in Data Structure

A Complete Guide to Implement Binary Tree in Data Structure

A Holistic Look at Using AVL Trees in Data Structures

All You Need to Know About Tree Traversal in Data Structure

The Best Guide You’ll Ever Need to Understand B-Tree in Data Structure

The Best Guide You'll Ever Need to Understand Spanning Tree in Data Structure

The Best and Easiest Way to Understand an Algorithm

Your One-Stop Solution to Understand Shell Sort Algorithm

Your One-Stop Solution to Quick Sort Algorithm

The Most Useful Guide to Learn Selection Sort Algorithm

Everything You Need to Know About Radix Sort Algorithm

Everything You Need to Know About the Counting Sort Algorithm

Everything You Need to Know About the Merge Sort Algorithm

Insertion Sort Algorithm: One-Stop Solution That Will Help You Understand Insertion Sort

Everything You Need to Know About the Bubble Sort Algorithm

The Best Guide You’ll Ever Need to Understand Bucket Sort Algorithm

Your One-Stop Solution to Understand Recursive Algorithm in Programming

The Definitive Guide to Understanding Greedy Algorithm

Your One-Stop Solution to Understand Backtracking Algorithm

The Fundamentals of the Bellman-Ford Algorithm

Your One-Stop Solution for Graphs in Data Structures

The Best Guide to Understand and Implement Solutions for Tower of Hanoi Puzzle

A Simplified and Complete Guide to Learn Space and Time Complexity

All You Need to Know About the Knapsack Problem : Your Complete Guide

The Fibonacci Series: Mathematical and Programming Interpretation

The Holistic Look at Longest Common Subsequence Problem

The Best Article to Understand What Is Dynamic Programming

A Guide to Implement Longest Increasing Subsequence Using Dynamic Programming

A Holistic Guide to Learn Stop Solution Using Dynamic Programming

One Stop Solution to All the Dynamic Programming Problems

Understanding the Fundamentals of Binomial Distribution

Here’s All You Need to Know About Minimum Spanning Tree in Data Structures

Understanding the Difference Between Array and Linked List

The Best Article Out There to Understand the B+ Tree in Data Structure

A Comprehensive Look at Queue in Data Structure

Your One-Stop Solution to Understand Coin Change Problem