What linked list begins with a pointer to the first node contains a pointer to the next node and the point node points back to the first node?

Find first node of loop in a linked list

Write a function findFirstLoopNode() that checks whether a given Linked List contains a loop. If the loop is present then it returns point to the first node of the loop. Else it returns NULL.

Example :

Input : Head of below linked list

Output : Pointer to node 2

Recommended: Please try your approach on {IDE} first, before moving on to the solution.

We have discussed Floyd’s loop detection algorithm. Below are steps to find the first node of the loop.
1. If a loop is found, initialize a slow pointer to head, let fast pointer be at its position.
2. Move both slow and fast pointers one node at a time.
3. The point at which they meet is the start of the loop.

C++

// C++ program to return first node of loop.
#include <bits/stdc++.h>

using namespace std;

struct Node {

int key;

struct Node* next;
};

Node* newNode(int key)
{

Node* temp = new Node;

temp->key = key;

temp->next = NULL;

return temp;
}
// A utility function to print a linked list

void printList(Node* head)
{

while (head != NULL) {

cout << head->key << " ";

head = head->next;

}

cout << endl;
}
// Function to detect and remove loop
// in a linked list that may contain loop
Node* detectAndRemoveLoop(Node* head)
{

// If list is empty or has only one node

// without loop

if (head == NULL || head->next == NULL)

return NULL;

Node *slow = head, *fast = head;

// Move slow and fast 1 and 2 steps

// ahead respectively.

slow = slow->next;

fast = fast->next->next;

// Search for loop using slow and

// fast pointers

while (fast && fast->next) {

if (slow == fast)

break;

slow = slow->next;

fast = fast->next->next;

}

// If loop does not exist

if (slow != fast)

return NULL;

// If loop exists. Start slow from

// head and fast from meeting point.

slow = head;

while (slow != fast) {

slow = slow->next;

fast = fast->next;

}

return slow;
}
/* Driver program to test above function*/

int main()
{

Node* head = newNode(50);

head->next = newNode(20);

head->next->next = newNode(15);

head->next->next->next = newNode(4);

head->next->next->next->next = newNode(10);

/* Create a loop for testing */

head->next->next->next->next->next = head->next->next;

Node* res = detectAndRemoveLoop(head);

if (res == NULL)

cout << "Loop does not exist";

else

cout << "Loop starting node is " << res->key;

return 0;
}

Java

// Java program to return 
// first node of loop.

import java.util.*;

class GFG{

static class Node
{

int key;

Node next;
};

static Node newNode(int key)
{

Node temp = new Node();

temp.key = key;

temp.next = null;

return temp;
}
// A utility function to 
// print a linked list

static void printList(Node head)
{

while (head != null)

{

System.out.print(head.key + " ");

head = head.next;

}

System.out.println();
}
// Function to detect and remove loop
// in a linked list that may contain loop

static Node detectAndRemoveLoop(Node head)
{

// If list is empty or has

// only one node without loop

if (head == null || head.next == null)

return null;

Node slow = head, fast = head;

// Move slow and fast 1

// and 2 steps ahead

// respectively.

slow = slow.next;

fast = fast.next.next;

// Search for loop using

// slow and fast pointers

while (fast != null &&

fast.next != null)

{

if (slow == fast)

break;

slow = slow.next;

fast = fast.next.next;

}

// If loop does not exist

if (slow != fast)

return null;

// If loop exists. Start slow from

// head and fast from meeting point.

slow = head;

while (slow != fast)

{

slow = slow.next;

fast = fast.next;

}

return slow;
}
// Driver code

public static void main(String[] args)
{

Node head = newNode(50);

head.next = newNode(20);

head.next.next = newNode(15);

head.next.next.next = newNode(4);

head.next.next.next.next = newNode(10);

// Create a loop for testing

head.next.next.next.next.next = head.next.next;

Node res = detectAndRemoveLoop(head);

if (res == null)

System.out.print("Loop does not exist");

else

System.out.print("Loop starting node is " + res.key);
}
}
// This code is contributed by shikhasingrajput

Python3

# Python3 program to return first node of loop.

class Node:

def __init__(self, key):

self.key = key

self.next = None

def newNode(key):

temp = Node(key)

return temp
# A utility function to print a linked list

def printList(head):

while (head != None):

print(head.key, end = ' ')

head = head.next

print()

# Function to detect and remove loop
# in a linked list that may contain loop

def detectAndRemoveLoop(head):

# If list is empty or has only one node

# without loop

if (head == None or head.next == None):

return None

slow = head

fast = head

# Move slow and fast 1 and 2 steps

# ahead respectively.

slow = slow.next

fast = fast.next.next

# Search for loop using slow and

# fast pointers

while (fast and fast.next):

if (slow == fast):

break

slow = slow.next

fast = fast.next.next

# If loop does not exist

if (slow != fast):

return None

# If loop exists. Start slow from

# head and fast from meeting point.

slow = head

while (slow != fast):

slow = slow.next

fast = fast.next

return slow
# Driver code

if __name__=='__main__':

head = newNode(50)

head.next = newNode(20)

head.next.next = newNode(15)

head.next.next.next = newNode(4)

head.next.next.next.next = newNode(10)

# Create a loop for testing

head.next.next.next.next.next = head.next.next

res = detectAndRemoveLoop(head)

if (res == None):

print("Loop does not exist")

else:

print("Loop starting node is " +

str(res.key))

# This code is contributed by rutvik_56

// C# program to return 
// first node of loop.

using System;

class GFG{

class Node
{

public int key;

public Node next;
};

static Node newNode(int key)
{

Node temp = new Node();

temp.key = key;

temp.next = null;

return temp;
}
// A utility function to 
// print a linked list

static void printList(Node head)
{

while (head != null)

{

Console.Write(head.key + " ");

head = head.next;

}

Console.WriteLine();
}
// Function to detect and remove loop
// in a linked list that may contain loop

static Node detectAndRemoveLoop(Node head)
{

// If list is empty or has

// only one node without loop

if (head == null || head.next == null)

return null;

Node slow = head, fast = head;

// Move slow and fast 1

// and 2 steps ahead

// respectively.

slow = slow.next;

fast = fast.next.next;

// Search for loop using

// slow and fast pointers

while (fast != null &&

fast.next != null)

{

if (slow == fast)

break;

slow = slow.next;

fast = fast.next.next;

}

// If loop does not exist

if (slow != fast)

return null;

// If loop exists. Start slow from

// head and fast from meeting point.

slow = head;

while (slow != fast)

{

slow = slow.next;

fast = fast.next;

}

return slow;
}
// Driver code

public static void Main(String[] args)
{

Node head = newNode(50);

head.next = newNode(20);

head.next.next = newNode(15);

head.next.next.next = newNode(4);

head.next.next.next.next = newNode(10);

// Create a loop for testing

head.next.next.next.next.next =

head.next.next;

Node res = detectAndRemoveLoop(head);

if (res == null)

Console.Write("Loop does not exist");

else

Console.Write("Loop starting node is " +

res.key);
}
}
// This code is contributed by shikhasingrajput

Javascript

<script>
// Javascript program to return
// first node of loop.
class Node
{

constructor(key)

{

this.key=key;

this.next=null;

}
}
// A utility function to
// print a linked list

function printList(head)
{

while (head != null)

{

document.write(head.key + " ");

head = head.next;

}

document.write("<br>");
}
// Function to detect and remove loop
// in a linked list that may contain loop

function detectAndRemoveLoop(head)
{

// If list is empty or has

// only one node without loop

if (head == null || head.next == null)

return null;

let slow = head, fast = head;

// Move slow and fast 1

// and 2 steps ahead

// respectively.

slow = slow.next;

fast = fast.next.next;

// Search for loop using

// slow and fast pointers

while (fast != null &&

fast.next != null)

{

if (slow == fast)

break;

slow = slow.next;

fast = fast.next.next;

}

// If loop does not exist

if (slow != fast)

return null;

// If loop exists. Start slow from

// head and fast from meeting point.

slow = head;

while (slow != fast)

{

slow = slow.next;

fast = fast.next;

}

return slow;
}
// Driver code

let head = new Node(50);

head.next = new Node(20);

head.next.next = new Node(15);

head.next.next.next = new Node(4);

head.next.next.next.next = new Node(10);

// Create a loop for testing

head.next.next.next.next.next = head.next.next;

let res = detectAndRemoveLoop(head);

if (res == null)

document.write("Loop does not exist");

else

document.write("Loop starting node is " + res.key);
// This code is contributed by unknown2108
</script>

Output:

Loop starting node is 15

How does this approach work?
Let slow and fast meet at some point after Floyd’s Cycle finding algorithm. The below diagram shows the situation when the cycle is found.

We can conclude below from the above diagram

Distance traveled by fast pointer = 2 * (Distance traveled by slow pointer) (m + n*x + k) = 2*(m + n*y + k) Note that before meeting the point shown above, fast was moving at twice speed. x --> Number of complete cyclic rounds made by fast pointer before they meet first time y --> Number of complete cyclic rounds made by slow pointer before they meet first time

From the above equation, we can conclude below

m + k = (x-2y)*n Which means m+k is a multiple of n.

So if we start moving both pointers again at the same speed such that one pointer (say slow) begins from the head node of the linked list and other pointers (say fast) begins from the meeting point. When the slow pointer reaches the beginning of the loop (has made m steps), the fast pointer would have made also moved m steps as they are now moving the same pace. Since m+k is a multiple of n and fast starts from k, they would meet at the beginning. Can they meet before also? No, because the slow pointer enters the cycle first time after m steps.

Method 2:
In this method, a temporary node is created. The next pointer of each node that is traversed is made to point to this temporary node. This way we are using the next pointer of a node as a flag to indicate whether the node has been traversed or not. Every node is checked to see if the next is pointing to a temporary node or not. In the case of the first node of the loop, the second time we traverse it this condition will be true, hence we return that node.
The code runs in O(n) time complexity and uses constant memory space.

Below is the implementation of the above approach:

C++

// C++ program to return first node of loop
#include <bits/stdc++.h>

using namespace std;

struct Node {

int key;

struct Node* next;
};

Node* newNode(int key)
{

Node* temp = new Node;

temp->key = key;

temp->next = NULL;

return temp;
}
// A utility function to print a linked list

void printList(Node* head)
{

while (head != NULL) {

cout << head->key << " ";

head = head->next;

}

cout << endl;
}
// Function to detect first node of loop
// in a linked list that may contain loop
Node* detectLoop(Node* head)
{

// Create a temporary node

Node* temp = new Node;

while (head != NULL) {

// This condition is for the case

// when there is no loop

if (head->next == NULL) {

return NULL;

}

// Check if next is already

// pointing to temp

if (head->next == temp) {

break;

}

// Store the pointer to the next node

// in order to get to it in the next step

Node* nex = head->next;

// Make next point to temp

head->next = temp;

// Get to the next node in the list

head = nex;

}

return head;
}
/* Driver program to test above function*/

int main()
{

Node* head = newNode(50);

head->next = newNode(20);

head->next->next = newNode(15);

head->next->next->next = newNode(4);

head->next->next->next->next = newNode(10);

/* Create a loop for testing */

head->next->next->next->next->next = head->next->next;

Node* res = detectLoop(head);

if (res == NULL)

cout << "Loop does not exist";

else

cout << "Loop starting node is " << res->key;

return 0;
}

Java

// Java program to return first node of loop

import java.util.*;

class GFG{

static class Node
{

int key;

Node next;
};

static Node newNode(int key)
{

Node temp = new Node();

temp.key = key;

temp.next = null;

return temp;
}
// A utility function to print a linked list

static void printList(Node head)
{

while (head != null)

{

System.out.print(head.key + " ");

head = head.next;

}

System.out.println();
}
// Function to detect first node of loop
// in a linked list that may contain loop

static Node detectLoop(Node head)
{

// Create a temporary node

Node temp = new Node();

while (head != null)

{

// This condition is for the case

// when there is no loop

if (head.next == null)

{

return null;

}

// Check if next is already

// pointing to temp

if (head.next == temp)

{

break;

}

// Store the pointer to the next node

// in order to get to it in the next step

Node nex = head.next;

// Make next point to temp

head.next = temp;

// Get to the next node in the list

head = nex;

}

return head;
}
/* Driver program to test above function*/

public static void main(String[] args)
{

Node head = newNode(50);

head.next = newNode(20);

head.next.next = newNode(15);

head.next.next.next = newNode(4);

head.next.next.next.next = newNode(10);

/* Create a loop for testing */

head.next.next.next.next.next = head.next.next;

Node res = detectLoop(head);

if (res == null)

System.out.print("Loop does not exist");

else

System.out.print("Loop starting node is " +

res.key);
}
}
// This code is contributed by gauravrajput1

Python3

# Python3 program to return first node of loop

class Node:

def __init__(self, x):

self.key = x

self.next = None
# A utility function to print a linked list

def printList(head):

while (head != None):

print(head.key, end = " ")

head = head.next

# Function to detect first node of loop
# in a linked list that may contain loop

def detectLoop(head):

# Create a temporary node

temp = Node(-1)

while (head != None):

# This condition is for the case

# when there is no loop

if (head.next == None):

return None

# Check if next is already

# pointing to temp

if (head.next == temp):

break

# Store the pointer to the next node

# in order to get to it in the next step

nex = head.next

# Make next point to temp

head.next = temp

# Get to the next node in the list

head = nex

return head
# Driver code

if __name__ == '__main__':

head = Node(50)

head.next = Node(20)

head.next.next = Node(15)

head.next.next.next = Node(4)

head.next.next.next.next = Node(10)

# Create a loop for testing

head.next.next.next.next.next = head.next.next

res = detectLoop(head)

if (res == None):

print("Loop does not exist")

else:

print("Loop starting node is ", res.key)
# This code is contributed by mohit kumar 29

// C# program to return first node of loop

using System;

class GFG{

class Node
{

public int key;

public Node next;
};

static Node newNode(int key)
{

Node temp = new Node();

temp.key = key;

temp.next = null;

return temp;
}
// A utility function to print a linked list

static void printList(Node head)
{

while (head != null)

{

Console.Write(head.key + " ");

head = head.next;

}

Console.WriteLine();
}
// Function to detect first node of loop
// in a linked list that may contain loop

static Node detectLoop(Node head)
{

// Create a temporary node

Node temp = new Node();

while (head != null)

{

// This condition is for the case

// when there is no loop

if (head.next == null)

{

return null;

}

// Check if next is already

// pointing to temp

if (head.next == temp)

{

break;

}

// Store the pointer to the next node

// in order to get to it in the next step

Node nex = head.next;

// Make next point to temp

head.next = temp;

// Get to the next node in the list

head = nex;

}

return head;
}
// Driver code

public static void Main(String[] args)
{

Node head = newNode(50);

head.next = newNode(20);

head.next.next = newNode(15);

head.next.next.next = newNode(4);

head.next.next.next.next = newNode(10);

// Create a loop for testing

head.next.next.next.next.next = head.next.next;

Node res = detectLoop(head);

if (res == null)

Console.Write("Loop does not exist");

else

Console.Write("Loop starting node is " +

res.key);
}
}
// This code is contributed by Amit Katiyar

Javascript

<script>
// javascript program to return first node of loop

class Node {

constructor() {

this.key = 0;

this.next = null;

}

}

function newNode(key) {

temp = new Node();

temp.key = key;

temp.next = null;

return temp;

}

// A utility function to print a linked list

function printList( head) {

while (head != null) {

document.write(head.key + " ");

head = head.next;

}

document.write("<br/>");

}

// Function to detect first node of loop

// in a linked list that may contain loop

function detectLoop( head) {

// Create a temporary node

temp = new Node();

while (head != null) {

// This condition is for the case

// when there is no loop

if (head.next == null) {

return null;

}

// Check if next is already

// pointing to temp

if (head.next == temp) {

break;

}

// Store the pointer to the next node

// in order to get to it in the next step

nex = head.next;

// Make next point to temp

head.next = temp;

// Get to the next node in the list

head = nex;

}

return head;

}

/* Driver program to test above function */

head = newNode(50);

head.next = newNode(20);

head.next.next = newNode(15);

head.next.next.next = newNode(4);

head.next.next.next.next = newNode(10);

/* Create a loop for testing */

head.next.next.next.next.next = head.next.next;

res = detectLoop(head);

if (res == null)

document.write("Loop does not exist");

else

document.write("Loop starting node is " + res.key);
// This code contributed by gauravrajput1 
</script>

Output: Loop starting node is 15

Method 3:
We can also use the concept of hashing in order to detect the first node of the loop. The idea is simple just iterate over the entire linked list and store node addresses in a set(C++ STL) one by one, while adding the node address into the set check if it already contains that particular node address if not then add node address to set if it is already present in the set then the current node is the first node of the loop.

C++14

// The below function take head of Linked List as
// input and return Address of first node in
// the loop if present else return NULL.
/* Definition for singly-linked list.

* struct ListNode {

* int val;

* ListNode *next;

* ListNode(int x) : val(x), next(NULL) {}

* };*/
ListNode* detectCycle(ListNode* A)
{

// declaring map to store node address

unordered_set<ListNode*> uset;

ListNode *ptr = A;

// Default consider that no cycle is present

while (ptr != NULL) {

// checking if address is already present in map

if (uset.find(ptr) != uset.end())

return ptr;

// if address not present then insert into the set

else

uset.insert(ptr);

ptr = ptr->next;

}

return NULL;
}
// This code is contributed by Pankaj_Joshi

Java

// The below function take head of Linked List as
// input and return Address of first node in
// the loop if present else return NULL.

import java.io.*;

import java.util.*;

class GFG
{

static Node detectCycle(Node A)

{

// declaring map to store node address

Set<Node> uset = new HashSet<Node>();

Node = A;

// Default consider that no cycle is present

while (ptr != NULL)

{

// checking if address is already present in map

if(uset.contains(ptr))

{

return ptr;

}

// if address not present then insert into the set

else

{

uset.add(ptr);

}

ptr = ptr.next;

}

return null;

}
}
// This code is contributed by avanitrachhadiya2155

Python3

# The below function take head of Linked List as
# input and return Address of first node in
# the loop if present else return NULL.

''' Definition for singly-linked list.

* class ListNode:

* def __init__(self, x):

* self.val=x

* self.next=None

* '''

def detectCycle(A):

# Declaring map to store node

# address

uset = set()

ptr = A

# Default consider that no cycle

# is present

while (ptr != None):

# Checking if address is already

# present in map

if (ptr in uset):

return ptr

# If address not present then

# insert into the set

else:

uset.add(ptr)

ptr = ptr.next

return None
# This code is contributed by pratham76

// The below function take head of Linked List as
// input and return Address of first node in
// the loop if present else return NULL.

using System.Collections.Generic;

public class GFG
{

class Node
{

public int key;

public Node next;
};

static Node detectCycle(Node A)

{

// declaring map to store node address

HashSet<Node> uset = new HashSet<Node>();

Node ptr = A;

// Default consider that no cycle is present

while (ptr != null)

{

// checking if address is already present in map

if(uset.Contains(ptr))

{

return ptr;

}

// if address not present then insert into the set

else

{

uset.Add(ptr);

}

ptr = ptr.next;

}

return null;

}
}
// This code is contributed by 29AjayKumar

Javascript

<script>
// The below function take head of Linked List as
// input and return Address of first node in
// the loop if present else return NULL.

function detectCycle(A)

{

// declaring map to store node address

let uset = new Set();

let ptr = A;

// Default consider that no cycle is present

while (ptr != NULL)

{

// checking if address is already present in map

if(uset.has(ptr))

{

return ptr;

}

// if address not present then insert into the set

else

{

uset.add(ptr);

}

ptr = ptr.next;

}

return null;

}
// This code is contributed by patel2127
</script>

Article Tags :

Linked List

Practice Tags :

Linked List

Read Full Article

What is a singly linked list?

A singly linked list is a type of linked list that is unidirectional, that is, it can be traversed in only one direction from head to the last node (tail).

Each element in a linked list is called a node. A single node contains data and a pointer to the next node which helps in maintaining the structure of the list.

The first node is called the head; it points to the first node of the list and helps us access every other element in the list. The last node, also sometimes called the tail, points to NULL which helps us in determining when the list ends.

An example of a singly Linked List

Pointers to a single struct object

Until now, we've used pointers to point to arrays of objects, rather than individual objects. It turns out that pointers to individual objects are very important in a wide range of circumstances.

new and delete

You can allocate a single object of a given type by just leaving the square brackets off the new statement. For example, to create a single point object and a pointer, p, that points to it, we could write:point* p = new point;To delete the point that p points to, you use the usual delete statement, except without the square brackets.delete p;

operator ->

In order to access a data-member of a struct from a pointer, one can use the -> operator. The pointer goes on the left, the name of the data member goes on the right. For example: point* ptr = new point; ptr->x = 0; ptr->y = 0;

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]

Linked lists

Introduction

Linked lists are the best and simplest example of a dynamic data structure that uses pointers for its implementation. However, understanding pointers is crucial to understanding how linked lists work, so if you've skipped the pointers tutorial, you should go back and redo it. You must also be familiar with dynamic memory allocation and structures.

Essentially, linked lists function as an array that can grow and shrink as needed, from any point in the array.

Linked lists have a few advantages over arrays:

Items can be added or removed from the middle of the list
There is no need to define an initial size

However, linked lists also have a few disadvantages:

There is no "random" access - it is impossible to reach the nth item in the array without first iterating over all items up until that item. This means we have to start from the beginning of the list and count how many times we advance in the list until we get to the desired item.
Dynamic memory allocation and pointers are required, which complicates the code and increases the risk of memory leaks and segment faults.
Linked lists have a much larger overhead over arrays, since linked list items are dynamically allocated (which is less efficient in memory usage) and each item in the list also must store an additional pointer.

What is a linked list?

A linked list is a set of dynamically allocated nodes, arranged in such a way that each node contains one value and one pointer. The pointer always points to the next member of the list. If the pointer is NULL, then it is the last node in the list.

A linked list is held using a local pointer variable which points to the first item of the list. If that pointer is also NULL, then the list is considered to be empty.

------------------------------ ------------------------------ | | | \ | | | | DATA | NEXT |--------------| DATA | NEXT | | | | / | | | ------------------------------ ------------------------------

Let's define a linked list node:

typedef struct node { int val; struct node * next; } node_t;

Notice that we are defining the struct in a recursive manner, which is possible in C. Let's name our node type node_t.

Now we can use the nodes. Let's create a local variable which points to the first item of the list (called head).

node_t * head = NULL; head = (node_t *) malloc(sizeof(node_t)); if (head == NULL) { return 1; } head->val = 1; head->next = NULL;

We've just created the first variable in the list. We must set the value, and the next item to be empty, if we want to finish populating the list. Notice that we should always check if malloc returned a NULL value or not.

To add a variable to the end of the list, we can just continue advancing to the next pointer:

node_t * head = NULL; head = (node_t *) malloc(sizeof(node_t)); head->val = 1; head->next = (node_t *) malloc(sizeof(node_t)); head->next->val = 2; head->next->next = NULL;

This can go on and on, but what we should actually do is advance to the last item of the list, until the next variable will be NULL.

Iterating over a list

Let's build a function that prints out all the items of a list. To do this, we need to use a current pointer that will keep track of the node we are currently printing. After printing the value of the node, we set the current pointer to the next node, and print again, until we've reached the end of the list (the next node is NULL).

void print_list(node_t * head) { node_t * current = head; while (current != NULL) { printf("%d\n", current->val); current = current->next; } }

Adding an item to the end of the list

To iterate over all the members of the linked list, we use a pointer called current. We set it to start from the head and then in each step, we advance the pointer to the next item in the list, until we reach the last item.

void push(node_t * head, int val) { node_t * current = head; while (current->next != NULL) { current = current->next; } /* now we can add a new variable */ current->next = (node_t *) malloc(sizeof(node_t)); current->next->val = val; current->next->next = NULL; }

The best use cases for linked lists are stacks and queues, which we will now implement:

Adding an item to the beginning of the list (pushing to the list)

To add to the beginning of the list, we will need to do the following:

Create a new item and set its value
Link the new item to point to the head of the list
Set the head of the list to be our new item

This will effectively create a new head to the list with a new value, and keep the rest of the list linked to it.

Since we use a function to do this operation, we want to be able to modify the head variable. To do this, we must pass a pointer to the pointer variable (a double pointer) so we will be able to modify the pointer itself.

void push(node_t ** head, int val) { node_t * new_node; new_node = (node_t *) malloc(sizeof(node_t)); new_node->val = val; new_node->next = *head; *head = new_node; }

Removing the first item (popping from the list)

To pop a variable, we will need to reverse this action:

Take the next item that the head points to and save it
Free the head item
Set the head to be the next item that we've stored on the side

Here is the code:

int pop(node_t ** head) { int retval = -1; node_t * next_node = NULL; if (*head == NULL) { return -1; } next_node = (*head)->next; retval = (*head)->val; free(*head); *head = next_node; return retval; }

Removing the last item of the list

Removing the last item from a list is very similar to adding it to the end of the list, but with one big exception - since we have to change one item before the last item, we actually have to look two items ahead and see if the next item is the last one in the list:

int remove_last(node_t * head) { int retval = 0; /* if there is only one item in the list, remove it */ if (head->next == NULL) { retval = head->val; free(head); return retval; } /* get to the second to last node in the list */ node_t * current = head; while (current->next->next != NULL) { current = current->next; } /* now current points to the second to last item of the list, so let's remove current->next */ retval = current->next->val; free(current->next); current->next = NULL; return retval; }

Removing a specific item

To remove a specific item from the list, either by its index from the beginning of the list or by its value, we will need to go over all the items, continuously looking ahead to find out if we've reached the node before the item we wish to remove. This is because we need to change the location to where the previous node points to as well.

Here is the algorithm:

Iterate to the node before the node we wish to delete
Save the node we wish to delete in a temporary pointer
Set the previous node's next pointer to point to the node after the node we wish to delete
Delete the node using the temporary pointer

There are a few edge cases we need to take care of, so make sure you understand the code.

int remove_by_index(node_t ** head, int n) { int i = 0; int retval = -1; node_t * current = *head; node_t * temp_node = NULL; if (n == 0) { return pop(head); } for (i = 0; i < n-1; i++) { if (current->next == NULL) { return -1; } current = current->next; } if (current->next == NULL) { return -1; } temp_node = current->next; retval = temp_node->val; current->next = temp_node->next; free(temp_node); return retval; }