GFG App
Open App
Browser
Continue

# 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

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
for(int i = 0; i < position; i++)
{
if(i == 0 && position == 1)
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 ` `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 ` `#include `   `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 ` `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<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.

My Personal Notes arrow_drop_up