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 *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)

Previous
Next