GeeksforGeeks App
Open App
Browser
Continue

Delete a given node in Linked List under given constraints

Given a Singly Linked List, write a function to delete a given node. Your function must follow following constraints:
1) It must accept a pointer to the start node as the first parameter and node to be deleted as the second parameter i.e., a pointer to head node is not global.
2) It should not return a pointer to the head node.
3) It should not accept pointer to pointer to the head node.
You may assume that the Linked List never becomes empty.
Let the function name be deleteNode(). In a straightforward implementation, the function needs to modify the head pointer when the node to be deleted is the first node. As discussed in previous post, when a function modifies the head pointer, the function must use one of the given approaches, we can’t use any of those approaches here.
Solution
We explicitly handle the case when the node to be deleted is the first node, we copy the data of the next node to the head and delete the next node. The cases when a deleted node is not the head node can be handled normally by finding the previous node and changing the next of the previous node. The following are the implementation.

C++

 `// C++ program to delete a given node``// in linked list under given constraints``#include ``using` `namespace` `std;`` ` `/* structure of a linked list node */``class` `Node ``{ ``    ``public``:``    ``int` `data; ``    ``Node *next; ``}; `` ` `void` `deleteNode(Node *head, Node *n) ``{ ``    ``// When node to be deleted is head node ``    ``if``(head == n) ``    ``{ ``        ``if``(head->next == NULL) ``        ``{ ``            ``cout << ``"There is only one node."` `<<``                    ``" The list can't be made empty "``; ``            ``return``; ``        ``} `` ` `        ``/* Copy the data of next node to head */``        ``head->data = head->next->data; `` ` `        ``// store address of next node ``        ``n = head->next; `` ` `        ``// Remove the link of next node ``        ``head->next = head->next->next; `` ` `        ``// free memory ``        ``free``(n); `` ` `        ``return``; ``    ``} `` ` ` ` `    ``// When not first node, follow ``    ``// the normal deletion process `` ` `    ``// find the previous node ``    ``Node *prev = head; ``    ``while``(prev->next != NULL && prev->next != n) ``        ``prev = prev->next; `` ` `    ``// Check if node really exists in Linked List ``    ``if``(prev->next == NULL) ``    ``{ ``        ``cout << ``"\nGiven node is not present in Linked List"``; ``        ``return``; ``    ``} `` ` `    ``// Remove node from Linked List ``    ``prev->next = prev->next->next; `` ` `    ``// Free memory ``    ``free``(n); `` ` `    ``return``; ``} `` ` `/* Utility function to insert a node at the beginning */``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; ``} `` ` `/* Utility function to print a linked list */``void` `printList(Node *head) ``{ ``    ``while``(head!=NULL) ``    ``{ ``        ``cout<data<<``" "``; ``        ``head=head->next; ``    ``} ``    ``cout<15->10->11->5->6->2->3 */``    ``push(&head,3); ``    ``push(&head,2); ``    ``push(&head,6); ``    ``push(&head,5); ``    ``push(&head,11); ``    ``push(&head,10); ``    ``push(&head,15); ``    ``push(&head,12); `` ` `    ``cout<<``"Given Linked List: "``; ``    ``printList(head); `` ` `    ``/* Let us delete the node with value 10 */``    ``cout<<``"\nDeleting node "``<< head->next->next->data<<``" "``; ``    ``deleteNode(head, head->next->next); `` ` `    ``cout<<``"\nModified Linked List: "``; ``    ``printList(head); `` ` `    ``/* Let us delete the first node */``    ``cout<<``"\nDeleting first node "``; ``    ``deleteNode(head, head); `` ` `    ``cout<<``"\nModified Linked List: "``; ``    ``printList(head); ``    ``return` `0; ``} `` ` `// This code is contributed by rathbhupendra`

C

 `#include ``#include `` ` `/* structure of a linked list node */``struct` `Node``{``    ``int` `data;``    ``struct` `Node *next;``};`` ` `void` `deleteNode(``struct` `Node *head, ``struct` `Node *n)``{``    ``// When node to be deleted is head node``    ``if``(head == n)``    ``{``        ``if``(head->next == NULL)``        ``{``            ``printf``(``"There is only one node. The list can't be made empty "``);``            ``return``;``        ``}`` ` `        ``/* Copy the data of next node to head */``        ``head->data = head->next->data;`` ` `        ``// store address of next node``        ``n = head->next;`` ` `        ``// Remove the link of next node``        ``head->next = head->next->next;`` ` `        ``// free memory``        ``free``(n);`` ` `        ``return``;``    ``}`` ` ` ` `    ``// When not first node, follow the normal deletion process`` ` `    ``// find the previous node``    ``struct` `Node *prev = head;``    ``while``(prev->next != NULL && prev->next != n)``        ``prev = prev->next;`` ` `    ``// Check if node really exists in Linked List``    ``if``(prev->next == NULL)``    ``{``        ``printf``(``"\n Given node is not present in Linked List"``);``        ``return``;``    ``}`` ` `    ``// Remove node from Linked List``    ``prev->next = prev->next->next;`` ` `    ``// Free memory``    ``free``(n);`` ` `    ``return``; ``}`` ` `/* Utility function to insert a node at the beginning */``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;``}`` ` `/* Utility function to print a linked list */``void` `printList(``struct` `Node *head)``{``    ``while``(head!=NULL)``    ``{``        ``printf``(``"%d "``,head->data);``        ``head=head->next;``    ``}``    ``printf``(``"\n"``);``}`` ` `/* Driver program to test above functions */``int` `main()``{``    ``struct` `Node *head = NULL;`` ` `    ``/* Create following linked list``      ``12->15->10->11->5->6->2->3 */``    ``push(&head,3);``    ``push(&head,2);``    ``push(&head,6);``    ``push(&head,5);``    ``push(&head,11);``    ``push(&head,10);``    ``push(&head,15);``    ``push(&head,12);`` ` `    ``printf``(``"Given Linked List: "``);``    ``printList(head);`` ` `    ``/* Let us delete the node with value 10 */``    ``printf``(``"\nDeleting node %d: "``, head->next->next->data);``    ``deleteNode(head, head->next->next);`` ` `    ``printf``(``"\nModified Linked List: "``);``    ``printList(head);`` ` `    ``/* Let us delete the first node */``    ``printf``(``"\nDeleting first node "``);``    ``deleteNode(head, head);`` ` `    ``printf``(``"\nModified Linked List: "``);``    ``printList(head);`` ` `    ``getchar``();``    ``return` `0;``}`

Python 3

 `# Node class``class` `Node:`` ` `    ``def` `__init__(``self``, data):``        ``self``.data ``=` `data``        ``self``.``next` `=` `None`` ` `# LinkedList class``class` `LinkedList:`` ` `    ``def` `__init__(``self``):``        ``self``.head ``=` `None`` ` `    ``def` `deleteNode(``self``, data):``        ``temp ``=` `self``.head``        ``prev ``=` `self``.head``        ``if` `temp.data ``=``=` `data:``            ``if` `temp.``next` `is` `None``:``                ``print``(``"Can't delete the node as it has only one node"``)``            ``else``:``                ``temp.data ``=` `temp.``next``.data``                ``temp.``next` `=` `temp.``next``.``next``            ``return``        ``while` `temp.``next` `is` `not` `None` `and` `temp.data !``=` `data:``            ``prev ``=` `temp``            ``temp ``=` `temp.``next``        ``if` `temp.``next` `is` `None` `and` `temp.data !``=``data:``            ``print``(``"Can't delete the node as it doesn't exist"``)``         ``# If node is last node of the linked list``        ``elif` `temp.``next` `is` `None` `and` `temp.data ``=``=` `data:``            ``prev.``next` `=` `None``        ``else``:``            ``prev.``next` `=` `temp.``next``              ` `         ` `    ``# To push a new element in the Linked List     ``    ``def` `push(``self``, new_data):``        ``new_node ``=` `Node(new_data)``        ``new_node.``next` `=` `self``.head``        ``self``.head ``=` `new_node`` ` `    ``# To print all the elements of the Linked List``    ``def` `PrintList(``self``):`` ` `        ``temp ``=` `self``.head``        ``while``(temp):``            ``print``(temp.data, end ``=` `" "``)``            ``temp ``=` `temp.``next`` ` `# Driver Code``llist ``=` `LinkedList()``llist.push(``3``)``llist.push(``2``)``llist.push(``6``)``llist.push(``5``)``llist.push(``11``)``llist.push(``10``)``llist.push(``15``)``llist.push(``12``)`` ` `print``(``"Given Linked List: "``, end ``=` `' '``)``llist.PrintList()``print``(``"\n\nDeleting node 10:"``)``llist.deleteNode(``10``)``print``(``"Modified Linked List: "``, end ``=` `' '``)``llist.PrintList()``print``(``"\n\nDeleting first node"``)``llist.deleteNode(``12``)``print``(``"Modified Linked List: "``, end ``=` `' '``)``llist.PrintList()`` ` `# This code is contributed by Akarsh Somani`

Java

 `// Java program to delete a given node ``// in linked list under given constraints`` ` `class` `LinkedList {`` ` `    ``static` `Node head;`` ` `    ``static` `class` `Node {`` ` `        ``int` `data;``        ``Node next;`` ` `        ``Node(``int` `d) {``            ``data = d;``            ``next = ``null``;``        ``}``    ``}`` ` `    ``void` `deleteNode(Node node, Node n) {``         ` `        ``// When node to be deleted is head node``        ``if` `(node == n) {``            ``if` `(node.next == ``null``) {``                ``System.out.println(``"There is only one node. The list "``                                 ``+ ``"can't be made empty "``);``                ``return``;``            ``}`` ` `            ``/* Copy the data of next node to head */``            ``node.data = node.next.data;`` ` `            ``// store address of next node``            ``n = node.next;`` ` `            ``// Remove the link of next node``            ``node.next = node.next.next;`` ` `            ``// free memory``            ``System.gc();`` ` `            ``return``;``        ``}`` ` `        ``// When not first node, follow the normal deletion process``        ``// find the previous node``        ``Node prev = node;``        ``while` `(prev.next != ``null` `&& prev.next != n) {``            ``prev = prev.next;``        ``}`` ` `        ``// Check if node really exists in Linked List``        ``if` `(prev.next == ``null``) {``            ``System.out.println(``"Given node is not present in Linked List"``);``            ``return``;``        ``}`` ` `        ``// Remove node from Linked List``        ``prev.next = prev.next.next;`` ` `        ``// Free memory``        ``System.gc();`` ` `        ``return``;``    ``}`` ` `    ``/* Utility function to print a linked list */``    ``void` `printList(Node head) {``        ``while` `(head != ``null``) {``            ``System.out.print(head.data + ``" "``);``            ``head = head.next;``        ``}``        ``System.out.println(``""``);``    ``}`` ` `    ``public` `static` `void` `main(String[] args) {``        ``LinkedList list = ``new` `LinkedList();``        ``list.head = ``new` `Node(``12``);``        ``list.head.next = ``new` `Node(``15``);``        ``list.head.next.next = ``new` `Node(``10``);``        ``list.head.next.next.next = ``new` `Node(``11``);``        ``list.head.next.next.next.next = ``new` `Node(``5``);``        ``list.head.next.next.next.next.next = ``new` `Node(``6``);``        ``list.head.next.next.next.next.next.next = ``new` `Node(``2``);``        ``list.head.next.next.next.next.next.next.next = ``new` `Node(``3``);`` ` `        ``System.out.println(``"Given Linked List :"``);``        ``list.printList(head);``        ``System.out.println(``""``);``         ` `        ``// Let us delete the node with value 10``        ``System.out.println(``"Deleting node :"` `+ head.next.next.data);``        ``list.deleteNode(head, head.next.next);`` ` `        ``System.out.println(``"Modified Linked list :"``);``        ``list.printList(head);``        ``System.out.println(``""``);`` ` `        ``// Let us delete the first node``        ``System.out.println(``"Deleting first Node"``);``        ``list.deleteNode(head, head);``        ``System.out.println(``"Modified Linked List"``);``        ``list.printList(head);`` ` `    ``}``}`` ` `// this code has been contributed by Mayank Jaiswal`

C#

 `// C# program to delete a given ``// node in linked list under ``// given constraints``using` `System;`` ` `public` `class` `LinkedList ``{`` ` `    ``Node head;`` ` `    ``class` `Node ``    ``{`` ` `        ``public` `int` `data;``        ``public` `Node next;`` ` `        ``public` `Node(``int` `d)``        ``{``            ``data = d;``            ``next = ``null``;``        ``}``    ``}`` ` `    ``void` `deleteNode(Node node, Node n)``    ``{``         ` `        ``// When node to be deleted is head node``        ``if` `(node == n)``        ``{``            ``if` `(node.next == ``null``) ``            ``{``                ``Console.WriteLine(``"There is only one node. The list "``                                ``+ ``"can't be made empty "``);``                ``return``;``            ``}`` ` `            ``/* Copy the data of next node to head */``            ``node.data = node.next.data;`` ` `            ``// store address of next node``            ``n = node.next;`` ` `            ``// Remove the link of next node``            ``node.next = node.next.next;`` ` `            ``// free memory``            ``GC.Collect();`` ` `            ``return``;``        ``}`` ` `        ``// When not first node, follow``        ``// the normal deletion process``        ``// find the previous node``        ``Node prev = node;``        ``while` `(prev.next != ``null` `&& prev.next != n) ``        ``{``            ``prev = prev.next;``        ``}`` ` `        ``// Check if node really exists in Linked List``        ``if` `(prev.next == ``null``) ``        ``{``            ``Console.WriteLine(``"Given node is not"` `+``                               ``"present in Linked List"``);``            ``return``;``        ``}`` ` `        ``// Remove node from Linked List``        ``prev.next = prev.next.next;`` ` `        ``// Free memory``        ``GC.Collect();`` ` `        ``return``;``    ``}`` ` `    ``/* Utility function to print a linked list */``    ``void` `printList(Node head) ``    ``{``        ``while` `(head != ``null``)``        ``{``            ``Console.Write(head.data + ``" "``);``            ``head = head.next;``        ``}``        ``Console.WriteLine(``""``);``    ``}`` ` `    ``// Driver code``    ``public` `static` `void` `Main(String[] args)``    ``{``        ``LinkedList list = ``new` `LinkedList();``        ``list.head = ``new` `Node(12);``        ``list.head.next = ``new` `Node(15);``        ``list.head.next.next = ``new` `Node(10);``        ``list.head.next.next.next = ``new` `Node(11);``        ``list.head.next.next.next.next = ``new` `Node(5);``        ``list.head.next.next.next.next.next = ``new` `Node(6);``        ``list.head.next.next.next.next.next.next = ``new` `Node(2);``        ``list.head.next.next.next.next.next.next.next = ``new` `Node(3);`` ` `        ``Console.WriteLine(``"Given Linked List :"``);``        ``list.printList(list.head);``        ``Console.WriteLine(``""``);``         ` `        ``// Let us delete the node with value 10``        ``Console.WriteLine(``"Deleting node :"` `+``                            ``list.head.next.next.data);``        ``list.deleteNode(list.head, list.head.next.next);`` ` `        ``Console.WriteLine(``"Modified Linked list :"``);``        ``list.printList(list.head);``        ``Console.WriteLine(``""``);`` ` `        ``// Let us delete the first node``        ``Console.WriteLine(``"Deleting first Node"``);``        ``list.deleteNode(list.head, list.head);``        ``Console.WriteLine(``"Modified Linked List"``);``        ``list.printList(list.head);``    ``}``} `` ` `// This code is contributed by Rajput-Ji`

Javascript

 ``

Output:

```Given Linked List: 12 15 10 11 5 6 2 3

Deleting node 10:
Modified Linked List: 12 15 11 5 6 2 3

Deleting first node
Modified Linked List: 15 11 5 6 2 3```

TIme Complexity: O(n)

As we are traversing the list only once.

Auxiliary Space: O(1)

As constant extra space is used.

Please write comments if you find the above codes/algorithms incorrect, or find other ways to solve the same problem.

My Personal Notes arrow_drop_up