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:
#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 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;
} |
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
}
} |
# 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) |
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); |
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);
}
} |
[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++ 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;
} |
# 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) |
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 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 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);
}
} |
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)