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; } |
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) |
[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)
Delete the first node in a linked list where data == key:
Since every node of the linked list is dynamically allocated using malloc() in C, we need to call free() for freeing memory allocated for the node to be deleted.
C++
// A complete working C++ program to // demonstrate deletion in singly // linked list with class #include <bits/stdc++.h> using namespace std; // A linked list node class Node { public : int data; Node* next; }; // Given a reference (pointer to pointer) // to the head of a list and an int, // inserts a new node on the front of the // list. void push(Node** head_ref, int new_data) { Node* new_node = new Node(); new_node->data = new_data; new_node->next = (*head_ref); (*head_ref) = new_node; } // Given a reference (pointer to pointer) // to the head of a list and a key, deletes // the first occurrence of key in linked list void deleteNode(Node** head_ref, int key) { // Store head node Node* temp = *head_ref; Node* prev = NULL; // If head node itself holds // the key to be deleted if (temp != NULL && temp->data == key) { // Changed head *head_ref = temp->next; // free old head delete temp; return ; } // Else Search for the key to be // deleted, keep track of the // previous node as we need to // change 'prev->next' else { while (temp != NULL && temp->data != key) { prev = temp; temp = temp->next; } // If key was not present in linked list if (temp == NULL) return ; // Unlink the node from linked list prev->next = temp->next; // Free memory delete temp; } } // This function prints contents of // linked list starting from the // given node void printList(Node* node) { while (node != NULL) { cout << node->data << " " ; node = node->next; } } // Driver code int main() { // Start with the empty list Node* head = NULL; // Add elements in linked list push(&head, 7); push(&head, 1); push(&head, 3); push(&head, 2); puts ( "Created Linked List: " ); printList(head); deleteNode(&head, 1); puts ( "\nLinked List after Deletion of 1: " ); printList(head); return 0; } // This code is contributed by ac121102 |
C
// A complete working C program // to demonstrate deletion in // singly linked list #include <stdio.h> #include <stdlib.h> // A linked list node struct Node { int data; struct Node* next; }; /* Given a reference (pointer to pointer) to the head of a list and an int, inserts a new node on the front of the list. */ void push( struct Node** head_ref, int new_data) { struct Node* new_node = ( struct Node*) malloc ( sizeof ( struct Node)); new_node->data = new_data; new_node->next = (*head_ref); (*head_ref) = new_node; } /* Given a reference (pointer to pointer) to the head of a list and a key, deletes the first occurrence of key in linked list */ void deleteNode( struct Node** head_ref, int key) { // Store head node struct Node *temp = *head_ref, *prev; // If head node itself holds the key to be deleted if (temp != NULL && temp->data == key) { *head_ref = temp->next; // Changed head free (temp); // free old head return ; } // Search for the key to be deleted, keep track of the // previous node as we need to change 'prev->next' while (temp != NULL && temp->data != key) { prev = temp; temp = temp->next; } // If key was not present in linked list if (temp == NULL) return ; // Unlink the node from linked list prev->next = temp->next; free (temp); // Free memory } // This function prints contents of linked list starting // from the given node void printList( struct Node* node) { while (node != NULL) { printf ( " %d " , node->data); node = node->next; } } // Driver code int main() { /* Start with the empty list */ struct Node* head = NULL; push(&head, 7); push(&head, 1); push(&head, 3); push(&head, 2); puts ( "Created Linked List: " ); printList(head); deleteNode(&head, 1); puts ( "\nLinked List after Deletion of 1: " ); printList(head); return 0; } |
Java
// A complete working Java program // to demonstrate deletion // in singly linked list import java.io.*; public class LinkedList { Node head; // head of list /* Linked list Node*/ class Node { int data; Node next; Node( int d) { data = d; next = null ; } } /* Given a key, deletes the first occurrence of key in * linked list */ void deleteNode( int key) { // Store head node Node temp = head, prev = null ; // If head node itself holds the key to be deleted if (temp != null && temp.data == key) { head = temp.next; // Changed head return ; } // Search for the key to be deleted, keep track of // the previous node as we need to change temp.next while (temp != null && temp.data != key) { prev = temp; temp = temp.next; } // If key was not present in linked list if (temp == null ) return ; // Unlink the node from linked list prev.next = temp.next; } /* Inserts a new Node at front of the list. */ public void push( int new_data) { Node new_node = new Node(new_data); new_node.next = head; head = new_node; } /* This function prints contents of linked list starting from the given node */ public void printList() { Node tnode = head; while (tnode != null ) { System.out.print(tnode.data + " " ); tnode = tnode.next; } } /* Driver program to test above functions. Ideally this function should be in a separate user class. It is kept here to keep code compact */ public static void main(String[] args) { LinkedList llist = new LinkedList(); llist.push( 7 ); llist.push( 1 ); llist.push( 3 ); llist.push( 2 ); System.out.println( "\nCreated Linked list is:" ); llist.printList(); llist.deleteNode( 1 ); // Delete node with data 1 System.out.println( "\nLinked List after Deletion of 1:" ); llist.printList(); } } |
Python3
# A complete working Python3 program to # demonstrate deletion in singly # linked list with class # Node class class Node: # Constructor to initialize the node object def __init__( self , data): self .data = data self . next = None class LinkedList: # Function to initialize head def __init__( self ): self .head = None # Function to insert a new node at the beginning def push( self , new_data): new_node = Node(new_data) new_node. next = self .head self .head = new_node # Given a reference to the head of a list and a key, # delete the first occurrence of key in linked list def deleteNode( self , key): # Store head node temp = self .head # If head node itself holds the key to be deleted if (temp is not None ): if (temp.data = = key): self .head = temp. next temp = None return # Search for the key to be deleted, keep track of the # previous node as we need to change 'prev.next' while (temp is not None ): if temp.data = = key: break prev = temp temp = temp. next # if key was not present in linked list if (temp = = None ): return # Unlink the node from linked list prev. next = temp. next temp = None # Utility function to print the linked LinkedList def printList( self ): temp = self .head while (temp): print ( " %d" % (temp.data)), temp = temp. next # Driver program llist = LinkedList() llist.push( 7 ) llist.push( 1 ) llist.push( 3 ) llist.push( 2 ) print ( "Created Linked List: " ) llist.printList() llist.deleteNode( 1 ) print ( "\nLinked List after Deletion of 1:" ) llist.printList() # This code is contributed by Nikhil Kumar Singh (nickzuck_007) |
C#
// A complete working C# program // to demonstrate deletion in // singly linked list using System; class GFG { // Head of list Node head; // Linked list Node public class Node { public int data; public Node next; public Node( int d) { data = d; next = null ; } } // Given a key, deletes the first // occurrence of key in linked list void deleteNode( int key) { // Store head node Node temp = head, prev = null ; // If head node itself holds // the key to be deleted if (temp != null && temp.data == key) { // Changed head head = temp.next; return ; } // Search for the key to be // deleted, keep track of the // previous node as we need // to change temp.next while (temp != null && temp.data != key) { prev = temp; temp = temp.next; } // If key was not present // in linked list if (temp == null ) return ; // Unlink the node from linked list prev.next = temp.next; } // Inserts a new Node at // front of the list. public void Push( int new_data) { Node new_node = new Node(new_data); new_node.next = head; head = new_node; } // This function prints contents // of linked list starting from // the given node public void printList() { Node tnode = head; while (tnode != null ) { Console.Write(tnode.data + " " ); tnode = tnode.next; } } // Driver code public static void Main(String[] args) { GFG llist = new GFG(); llist.Push(7); llist.Push(1); llist.Push(3); llist.Push(2); Console.WriteLine( "\nCreated Linked list is:" ); llist.printList(); // Delete node with data 1 llist.deleteNode(1); Console.WriteLine( "\nLinked List after Deletion of 1:" ); llist.printList(); } } // This code is contributed by Rajput-Ji |
Javascript
<script> // A complete working javascript program // to demonstrate deletion // in singly linked list var head; // head of list /* Linked list Node */ class Node { constructor(val) { this .data = val; this .next = null ; } } /* * Given a key, deletes the first occurrence of key in linked list */ function deleteNode(key) { // Store head node var temp = head, prev = null ; // If head node itself holds the key to be deleted if (temp != null && temp.data == key) { head = temp.next; // Changed head return ; } // Search for the key to be deleted, keep track of // the previous node as we need to change temp.next while (temp != null && temp.data != key) { prev = temp; temp = temp.next; } // If key was not present in linked list if (temp == null ) return ; // Unlink the node from linked list prev.next = temp.next; } /* Inserts a new Node at front of the list. */ function push(new_data) { var new_node = new Node(new_data); new_node.next = head; head = new_node; } /* * This function prints contents of linked list starting from the given node */ function printList() { tnode = head; while (tnode != null ) { document.write(tnode.data + " " ); tnode = tnode.next; } } /* * Driver program to test above functions. Ideally this function should be in a * separate user class. It is kept here to keep code compact */ push(7); push(1); push(3); push(2); document.write( "Created Linked list is:<br/>" ); printList(); deleteNode(1); // Delete node with data 1 document.write( "<br/>Linked List after Deletion of 1:<br/>" ); printList(); // This code is contributed by todaysgaurav </script> |
Created Linked List: 2 3 1 7 Linked List after Deletion of 1: 2 3 7
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) |
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)
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.
Please Login to comment...