Deletion in Linked List

We have discussed Linked List Introduction and Linked List Insertion in previous posts on a singly linked list.
Let us formulate the problem statement to understand the deletion process. 

Delete from a Linked List:-

You can delete an element in a list from:

• Beginning
• End
• Middle

1) Delete from Beginning:

Point head to the next node i.e. second node
    temp = head
    head = head->next
    
Make sure to free unused memory
    free(temp); or delete temp;

2) Delete from End:

Point head to the previous element i.e. last second element
    Change next pointer to null
    struct node *end = head;
    struct node *prev = NULL;
    while(end->next)
    {
        prev = end;
        end = end->next;
    }
    prev->next = NULL;
    
Make sure to free unused memory
    free(end); or delete end;

3) Delete from Middle:

Keeps track of pointer before node to delete and pointer to node to delete
    temp = head;
    prev = head;
    for(int i = 0; i < position; i++)
    {
        if(i == 0 && position == 1)
            head = head->next;
            free(temp)
        else
        {
            if (i == position - 1 && temp)
            {
                prev->next = temp->next;
                free(temp);
            }
            else
            {
                prev = temp;
                if(prev == NULL) // position was greater than number of nodes in the list
                    break;
                temp = temp->next; 
            }
        }
    }
    

Iterative Method to delete an element from the linked list:

To delete a node from the linked list, we need to do the following steps:

• Find the previous node of the node to be deleted. 
• Change the next of the previous node. 
• Free memory for the node to be deleted.

Below is the implementation to delete a node from the list at some position:

C++

#include <bits/stdc++.h>
using namespace std;

struct Node {
    int number;
    Node* next;
};

void Push(Node** head, int A)
{
    Node* n = (Node*)malloc(sizeof(Node));
    n->number = A;
    n->next = *head;
    *head = n;
}

void deleteN(Node** head, int position)
{
    Node* temp;
    Node* prev;
    temp = *head;
    prev = *head;
    for (int i = 0; i < position; i++) {
        if (i == 0 && position == 1) {
            *head = (*head)->next;
            free(temp);
        }
        else {
            if (i == position - 1 && temp) {
                prev->next = temp->next;
                free(temp);
            }
            else {
                prev = temp;

                // Position was greater than
                // number of nodes in the list
                if (prev == NULL)
                    break;
                temp = temp->next;
            }
        }
    }
}

void printList(Node* head)
{
    while (head) {
        if (head->next == NULL)
            cout << "[" << head->number << "] "
                 << "[" << head << "]->"
                 << "(nil)" << endl;
        else
            cout << "[" << head->number << "] "
                 << "[" << head << "]->" << head->next
                 << endl;
        head = head->next;
    }
    cout << endl << endl;
}

// Driver code
int main()
{
    Node* list = (Node*)malloc(sizeof(Node));
    list->next = NULL;
    Push(&list, 1);
    Push(&list, 2);
    Push(&list, 3);

    printList(list);

    // Delete any position from list
    deleteN(&list, 1);
    printList(list);
    return 0;
}

C

// C code to delete a node from linked list
#include <stdio.h>
#include <stdlib.h>

typedef struct Node {
    int number;
    struct Node* next;
} Node;

void Push(Node** head, int A)
{
    Node* n = malloc(sizeof(Node));
    n->number = A;
    n->next = *head;
    *head = n;
}

void deleteN(Node** head, int position)
{
    Node* temp;
    Node* prev;
    temp = *head;
    prev = *head;
    for (int i = 0; i < position; i++) {
        if (i == 0 && position == 1) {
            *head = (*head)->next;
            free(temp);
        }
        else {
            if (i == position - 1 && temp) {
                prev->next = temp->next;
                free(temp);
            }
            else {
                prev = temp;

                // Position was greater than
                // number of nodes in the list
                if (prev == NULL)
                    break;
                temp = temp->next;
            }
        }
    }
}

void printList(Node* head)
{
    while (head) {
        printf("[%i] [%p]->%p\n", head->number, head,
               head->next);
        head = head->next;
    }
    printf("\n\n");
}

// Drivers code
int main()
{
    Node* list = malloc(sizeof(Node));
    list->next = NULL;
    Push(&list, 1);
    Push(&list, 2);
    Push(&list, 3);

    printList(list);

    // Delete any position from list
    deleteN(&list, 1);
    printList(list);
    return 0;
}

Java

class Node {
  int number;
  Node next;
}

class Main {

  // This method adds a new node with a value A to the front of the linked list
  public static Node push(Node head, int A) {
    Node n = new Node(); // Create a new node
    n.number = A; // Assign the value A to the node
    n.next = head; // Set the next node of the new node to be the current head
    head = n; // Set the new node as the head of the linked list
    return head; // Return the new head of the linked list
  }

  // This method deletes the node at the given position from the linked list
  public static Node deleteN(Node head, int position) {
    Node temp = head; // Create a temporary node pointing to the head of the linked list
    Node prev = head; // Create a previous node pointing to the head of the linked list

    for (int i = 0; i < position; i++) { // Loop through the linked list to find the node at the given position
      if (i == 0 && position == 1) { // If the node to delete is the head
        head = head.next; // Set the next node as the new head
      } else {
        if (i == position - 1 && temp != null) { // If the node to delete is found
          prev.next = temp.next; // Set the next node of the previous node to be the next node of the current node
        } else {
          prev = temp; // Move the previous node to the current node

          // If the previous node is null, the position was greater than the number of nodes in the list
          if (prev == null)
            break;
          temp = temp.next; // Move the temporary node to the next node
        }
      }
    }
    return head; // Return the new head of the linked list
  }

  // This method prints the linked list
  public static void printList(Node head) {
    while (head != null) { // Loop through the linked list
      if (head.next == null) { // If the current node is the last node
        System.out.println("[" + head.number + "] [" + head + "]->" + "(null)"); // Print the node value and null
      } else {
        System.out.println("[" + head.number + "] [" + head + "]->" + head.next); // Print the node value and the next node
      }
      head = head.next; // Move to the next node
    }
    System.out.println();
    System.out.println();
  }

  public static void main(String[] args) {
    Node list = new Node(); // Create a new linked list
    list.next = null; // Set the next node of the first node to be null
    list = push(list, 1); // Add node with value 1 to the linked list
    list = push(list, 2); // Add node with value 2 to the linked list
    list = push(list, 3); // Add node with value 3 to the linked list

    printList(list); // Print the linked list

    // Delete node at position 1 from the linked list
    list = deleteN(list, 1);
    printList(list); // Print the updated linked list
  }
}

Python3

# Python program to implement the above approach
class Node:
    # constructor to initialize the node object
    def __init__(self, data):
        self.number = data
        self.next = None


def push(head, A):
    n = Node(A)
    n.number = A
    n.next = head
    head = n
    return head


def deleteN(head, position):
    temp = head
    prev = head
    for i in range(0, position):
        if i == 0 and position == 1:
            head = head.next

        else:
            if i == position-1 and temp is not None:
                prev.next = temp.next
            else:
                prev = temp

                # Position was greater than
                # number of nodes in the list
                if prev is None:
                    break
                temp = temp.next
    return head


def printList(head):
    while(head):
        if head.next == None:
            print("[", head.number, "] ", "[", hex(id(head)), "]->", "nil")
        else:
            print("[", head.number, "] ", "[", hex(
                id(head)), "]->", hex(id(head.next)))
        head = head.next
    print("")
    print("")


head = Node(0)
head = push(head, 1)
head = push(head, 2)
head = push(head, 3)

printList(head)

# Delete any position from list
head = deleteN(head, 1)
printList(head)

# This code is contributed by Yash Agawral(yashagawral2852002)

Javascript

class Node {
  constructor(number) {
    this.number = number;
    this.next = null;
  }
}

function push(head, number) {
  const node = new Node(number);
  node.next = head;
  head = node;
  return head;
}

function deleteN(head, position) {
  let temp = head;
  let prev = head;

  for (let i = 0; i < position; i++) {
    if (i === 0 && position === 1) {
      head = head.next;
      temp = null;
    } else {
      if (i === position - 1 && temp) {
        prev.next = temp.next;
        temp = null;
      } else {
        prev = temp;

        // Position was greater than
        // number of nodes in the list
        if (prev === null) break;

        temp = temp.next;
      }
    }
  }
  return head;
}

function printList(head) {
  while (head) {
    if (head.next === null)
      console.log(`[${head.number}] [${head}]->(nil)`);
    else console.log(`[${head.number}] [${head}]->${head.next}`);
    head = head.next;
  }
  console.log('\n');
}

// Driver code
let list = new Node(0);
list.next = null;
list = push(list, 1);
list = push(list, 2);
list = push(list, 3);

printList(list);

// Delete any position from list
list = deleteN(list, 1);
printList(list);

C#

using System;

public class Node {
    public int number;
    public Node next;
}

public class Program {
    public static void Push(ref Node head, int A)
    {
        Node n = new Node();
        n.number = A;
        n.next = head;
        head = n;
    }

    public static void deleteN(ref Node head, int position)
    {
        Node temp = head;
        Node prev = head;
        for (int i = 0; i < position; i++) {
            if (i == 0 && position == 1) {
                head = head.next;
                temp = null;
            }
            else {
                if (i == position - 1 && temp != null) {
                    prev.next = temp.next;
                    temp = null;
                }
                else {
                    prev = temp;

                    // Position was greater than
                    // number of nodes in the list
                    if (prev == null) {
                        break;
                    }
                    temp = temp.next;
                }
            }
        }
    }

    public static void printList(Node head)
    {
        while (head != null) {
            if (head.next == null) {
                Console.WriteLine("[" + head.number + "] "
                                  + "[" + head + "]->"
                                  + "(nil)");
            }
            else {
                Console.WriteLine("[" + head.number + "] "
                                  + "[" + head + "]->"
                                  + head.next);
            }
            head = head.next;
        }
        Console.WriteLine("\n");
    }

    // Driver code
    public static void Main()
    {
        Node list = new Node();
        list.next = null;
        Push(ref list, 1);
        Push(ref list, 2);
        Push(ref list, 3);

        printList(list);

        // Delete any position from list
        deleteN(ref list, 1);
        printList(list);
    }
}

Output

[3] [0x1b212c0]->0x1b212a0
[2] [0x1b212a0]->0x1b21280
[1] [0x1b21280]->0x1b21260
[0] [0x1b21260]->(nil)


[2] [0x1b212a0]->0x1b21280
[1] [0x1b21280]->0x1b21260
[0] [0x1b21260]->(nil)

Time Complexity: O(n)
Auxiliary Space: O(1)

Recursive Method to delete a node from linked list:

To delete a node of a linked list recursively we need to do the following steps:

• We pass node* (node pointer) as a reference to the function (as in node* &head)
• Now since the current node pointer is derived from the previous node’s next (which is passed by reference) so now if the value of the current node pointer is changed, the previous next node’s value also gets changed which is the required operation while deleting a node (i.e points previous node’s next to current node’s (containing key) next).
• Find the node containing the given value.
• Store this node to deallocate it later using the free() function.
• Change this node pointer so that it points to its next and by performing this previous node’s next also gets properly linked.

Below is the implementation of the above approach.

C++

// C++ program to delete a node in
// singly linked list recursively

#include <bits/stdc++.h>
using namespace std;

struct node {
    int info;
    node* link = NULL;
    node() {}
    node(int a)
        : info(a)
    {
    }
};

// Deletes the node containing 'info'
// part as val and alter the head of
// the linked list (recursive method)
void deleteNode(node*& head, int val)
{

    // Check if list is empty or we
    // reach at the end of the
    // list.
    if (head == NULL) {
        cout << "Element not present in the list\n";
        return;
    }

    // If current node is the
    // node to be deleted
    if (head->info == val) {
        node* t = head;

        // If it's start of the node head
        // node points to second node
        head = head->link;

        // Else changes previous node's
        // link to current node's link
        delete (t);
        return;
    }
    deleteNode(head->link, val);
}

// Utility function to add a
// node in the linked list
// Here we are passing head by
// reference thus no need to
// return it to the main function
void push(node*& head, int data)
{
    node* newNode = new node(data);
    newNode->link = head;
    head = newNode;
}

// Utility function to print
// the linked list (recursive
// method)
void print(node* head)
{

    // cout<<endl gets implicitly
    // typecasted to bool value
    // 'true'
    if (head == NULL and cout << endl)
        return;
    cout << head->info << ' ';
    print(head->link);
}

int main()
{

    // Starting with an empty linked list
    node* head = NULL;

    // Adds new element at the
    // beginning of the list
    push(head, 10);
    push(head, 12);
    push(head, 14);
    push(head, 15);

    // original list
    print(head);

    // Call to delete function
    deleteNode(head, 20);

    // 20 is not present thus no change
    // in the list
    print(head);

    deleteNode(head, 10);
    print(head);

    deleteNode(head, 14);
    print(head);

    return 0;
}

Python3

# Python program to delete a node in
# singly linked list recursively

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

# Deletes the node containing 'data'
# part as val and alter the head of
# the linked list (recursive method)
def deleteNode(head, val):
    # Check if list is empty or we
    # reach at the end of the
    # list.
    if (head == None):
        print("Element not present in the list")
        return -1
    # If current node is the
    # node to be deleted
    if (head.data == val):
        # If it's start of the node head
        # node points to second node
        if head.next:
            head.data = head.next.data
            head.next = head.next.next
            return 1
        else: return 0
    if deleteNode(head.next, val) == 0:
        head.next = None
        return 1

# Utility function to add a
# node in the linked list
# Here we are passing head by
# reference thus no need to
# return it to the main function
def push(head, data):
    newNode = Node(data)
    newNode.next = head
    head = newNode
    return head

# Utility function to print
# the linked list (recursive
# method)
def printLL(head):
    if (head == None):
        return
    temp = head
    while temp:
        print(temp.data,end=' ')
        temp = temp.next
    print()

# Driver Code

# Starting with an empty linked list
head = None
# Adds new element at the
# beginning of the list
head = push(head, 10)
head = push(head, 12)
head = push(head, 14)
head = push(head, 15)
# original list
printLL(head)
# Call to delete function
deleteNode(head, 20)
# 20 is not present thus no change
# in the list
printLL(head)
deleteNode(head, 10)
printLL(head)
deleteNode(head, 14)
printLL(head)

C#

using System;

class LinkedList
{
    public class Node
    {
        public int info;
        public Node link;

        public Node(int a)
        {
            info = a;
            link = null;
        }
    }

    // Deletes the node containing 'info' part as val and alters the head of the linked list (recursive method)
    public static void deleteNode(ref Node head, int val)
    {
        // Check if list is empty or we reach at the end of the list.
        if (head == null)
        {
            Console.WriteLine("Element not present in the list");
            return;
        }

        // If current node is the node to be deleted
        if (head.info == val)
        {
            Node t = head;

            // If it's start of the node head node points to second node
            head = head.link;

            // Delete the node
            t = null;
            return;
        }

        // Recursively call the function on the next node
        deleteNode(ref head.link, val);
    }

    // Utility function to add a node in the linked list. Here we are passing head by reference thus no need to return it to the main function.
    public static void push(ref Node head, int data)
    {
        Node newNode = new Node(data);
        newNode.link = head;
        head = newNode;
    }

    // Utility function to print the linked list (recursive method)
    public static void print(Node head)
    {
        // If head is null, it means we have reached the end of the list
        if (head == null)
        {
            Console.WriteLine();
            return;
        }

        Console.Write(head.info + " ");
        // Recursively print the remaining nodes
        print(head.link);
    }

    public static void Main(string[] args)
    {
        // Starting with an empty linked list
        Node head = null;

        // Adds new element at the beginning of the list
        push(ref head, 10);
        push(ref head, 12);
        push(ref head, 14);
        push(ref head, 15);

        // Print the original list
        print(head);

        // Call to delete function
        deleteNode(ref head, 20);

        // 20 is not present thus no change in the list
        print(head);

        // Delete nodes and print the list after each deletion
        deleteNode(ref head, 10);
        print(head);

        deleteNode(ref head, 14);
        print(head);
    }
}

Javascript

// JavaScript program to delete a node in
// singly linked list recursively
class Node {
    constructor(data) {
        this.data = data;
        this.next = null;
    }
}

// Deletes the node containing 'data'
// part as val and alter the head of
// the linked list (recursive method)
function deleteNode(head, val)
{

    // Check if list is empty or we
    // reach at the end of the
    // list.
    if (!head) {
        console.log("Element not present in the list");
        return -1;
    }

    // If current node is the
    // node to be deleted
    if (head.data == val) {

        // If it's start of the node head
        // node points to second node
        if (head.next) {
            head.data = head.next.data;
            head.next = head.next.next;
            return 1;
        } else return 0;
    }
    if (deleteNode(head.next, val) == 0) {
        head.next = null;
        return 1;
    }
}

// Utility function to add a
// node in the linked list
// Here we are passing head by
// reference thus no need to
// return it to the main function
function push(head, data) {
    let newNode = new Node(data);
    newNode.next = head;
    head = newNode;
    return head;
}

// Utility function to print
// the linked list (recursive
// method)
function printLL(head) {
    if (!head) return;
    let temp = head;
    while (temp) {
        console.log(temp.data, " ");
        temp = temp.next;
    }
    console.log();
}

// Driver Code

// Starting with an empty linked list
let head = null;

// Adds new element at the
// beginning of the list
head = push(head, 10);
head = push(head, 12);
head = push(head, 14);
head = push(head, 15);

// original list
printLL(head);

// Call to delete function
deleteNode(head, 20);

// 20 is not present thus no change
// in the list
printLL(head);
deleteNode(head, 10);
printLL(head);
deleteNode(head, 14);
printLL(head);

// This code is contributed by Prajwal Kandekar

Java

// Java program to delete a node in
// singly linked list recursively

class Node {
    int data;
    Node next;

    public Node(int data) {
        this.data = data;
        this.next = null;
    }
}

public class Main {

    // Deletes the node containing 'data'
    // part as val and alter the head of
    // the linked list (recursive method)
    public static int deleteNode(Node head, int val) {
        // Check if list is empty or we
        // reach at the end of the
        // list.
        if (head == null) {
            System.out.println("Element not present in the list");
            return -1;
        }
        // If current node is the
        // node to be deleted
        if (head.data == val) {
            // If it's start of the node head
            // node points to second node
            if (head.next != null) {
                head.data = head.next.data;
                head.next = head.next.next;
                return 1;
            } else
                return 0;
        }
        if (deleteNode(head.next, val) == 0) {
            head.next = null;
            return 1;
        }
        return -1;
    }

    // Utility function to add a
    // node in the linked list
    // Here we are passing head by
    // reference thus no need to
    // return it to the main function
    public static Node push(Node head, int data) {
        Node newNode = new Node(data);
        newNode.next = head;
        head = newNode;
        return head;
    }

    // Utility function to print
    // the linked list (recursive
    // method)
    public static void printLL(Node head) {
        if (head == null)
            return;
        Node temp = head;
        while (temp != null) {
            System.out.print(temp.data + " ");
            temp = temp.next;
        }
        System.out.println();
    }

    public static void main(String[] args) {
        // Starting with an empty linked list
        Node head = null;

        // Adds new element at the
        // beginning of the list
        head = push(head, 10);
        head = push(head, 12);
        head = push(head, 14);
        head = push(head, 15);

        // original list
        printLL(head);

        // Call to delete function
        deleteNode(head, 20);

        // 20 is not present thus no change
        // in the list
        printLL(head);

        deleteNode(head, 10);
        printLL(head);

        deleteNode(head, 14);
        printLL(head);
    }
}

Output

15 14 12 10 
Element not present in the list
15 14 12 10 
15 14 12 
15 12 

Time Complexity: O(n)
Auxiliary Space: O(n) (due to recursion call stack)

Example 

Here are the algorithmic steps for deleting a node from a linked list, whether it's from the beginning, middle, or end:

Deleting a node from the beginning:

Set the head node to the next node in the list.

Delete the original head node.

Deleting a node from the middle:

Traverse the linked list until you reach the node that you want to delete.

Set the node before the one you want to delete to point to the node after the one you want to delete.

Delete the node you wanted to delete.

Deleting a node from the end:

Traverse the linked list until you reach the second-to-last node in the list.

Set the next pointer of the second-to-last node to None.

Delete the last node in the list.


Note that in order to delete a node, you will typically need to keep track of the node before the one you want to delete as well, since this is the node that needs to have its next pointer updated. Additionally, be sure to properly deallocate any memory used by the deleted node to avoid memory leaks.

Python3

class Node:
    def __init__(self, val):
        self.val = val
        self.next = None

class LinkedList:
    def __init__(self):
        self.head = None

    def delete_beginning(self):
        if not self.head:
            return
        self.head = self.head.next

    def delete_middle(self, target):
        if not self.head:
            return
        if self.head.val == target:
            self.delete_beginning()
            return
        prev = self.head
        curr = prev.next
        while curr:
            if curr.val == target:
                prev.next = curr.next
                return
            prev = curr
            curr = curr.next

    def delete_end(self):
        if not self.head:
            return
        if not self.head.next:
            self.head = None
            return
        prev = self.head
        curr = prev.next
        while curr.next:
            prev = curr
            curr = curr.next
        prev.next = None

    def printList(self):
        curr = self.head
        while curr:
            print(curr.val, end=" ")
            curr = curr.next
        print()

# Create a linked list
llist = LinkedList()
llist.head = Node(1)
second = Node(2)
third = Node(3)
fourth = Node(4)
fifth = Node(5)

llist.head.next = second
second.next = third
third.next = fourth
fourth.next = fifth

# Print the original linked list
print("Original linked list: ")
llist.printList()

# Delete a node from the beginning of the linked list
llist.delete_beginning()
print("Linked list after deleting the beginning node: ")
llist.printList()

# Delete a node from the middle of the linked list
llist.delete_middle(3)
print("Linked list after deleting a middle node: ")
llist.printList()

# Delete a node from the end of the linked list
llist.delete_end()
print("Linked list after deleting the end node: ")
llist.printList()

Output

Original linked list: 
1 2 3 4 5 
Linked list after deleting the beginning node: 
2 3 4 5 
Linked list after deleting a middle node: 
2 4 5 
Linked list after deleting the end node: 
2 4 

In this example, we first create a linked list with five nodes, print the original linked list, delete a node from the beginning of the list using the delete_beginning() method, print the updated list, delete a node from the middle of the list using the delete_middle() method, print the updated list again, delete a node from the end of the list using the delete_end() method, and print the final updated list.

Time and space complexity

The time complexity of deleting a node from a linked list at the beginning, middle, or end is O(n), where n is the number of nodes in the linked list. This is because we need to traverse the linked list to find the node that needs to be deleted, and in the worst case, we may need to traverse the entire list.

The space complexity of the algorithm is O(1), which is constant space, because we are only using a few variables to traverse the linked list and perform the deletion, and we are not using any additional data structures. Therefore, the space used by the algorithm does not depend on the size of the input.

Please write comments if you find anything incorrect, or if you want to share more information about the topic discussed above.