# Given only a pointer to a node to be deleted in a singly linked list, how do you delete it?

• Difficulty Level : Easy
• Last Updated : 26 Jul, 2021

A simple solution is to traverse the linked list until you find the node you want to delete. But this solution requires a pointer to the head node which contradicts the problem statement.

The fast solution is to copy the data from the next node to the node to be deleted and delete the next node. Something like this:

It is important to note that this approach will only work if it is guaranteed that the given pointer does not point to the last node. Because if it is the last node, then you don’t have a next node to copy the data from.

```struct Node *temp  = node_ptr->next;
node_ptr->data  = temp->data;
node_ptr->next  = temp->next;
free(temp);```

Below is the implementation of the above code:

## C++

 `// C++ program to del the node` `// in which only a single pointer` `// is known pointing to that node` `#include ` `#include ` `using` `namespace` `std;`   `/* Link list node */` `class` `Node {` `public``:` `    ``int` `data;` `    ``Node* next;` `};`   `/* Given a reference (pointer to pointer) to the head` `of a list and an int, push a new node on the front` `of the list. */` `void` `push(Node** head_ref, ``int` `new_data)` `{` `    ``/* allocate node */` `    ``Node* new_node = ``new` `Node();`   `    ``/* put in the data */` `    ``new_node->data = new_data;`   `    ``/* link the old list off the new node */` `    ``new_node->next = (*head_ref);`   `    ``/* move the head to point to the new node */` `    ``(*head_ref) = new_node;` `}`   `void` `printList(Node* head)` `{` `    ``Node* temp = head;` `    ``while` `(temp != NULL) {` `        ``cout << temp->data << ``" "``;` `        ``temp = temp->next;` `    ``}` `}`   `void` `deleteNode(Node* node_ptr)` `{` `    ``// If the node to be deleted is the ` `    ``// last node of linked list` `    ``if` `(node_ptr->next == NULL)` `    ``{` `        ``free``(node_ptr);` `        ``// this will simply make the node_ptr NULL.` `        ``return``;` `    ``}` `    `  `    ``// if node to be deleted is the first or ` `    ``// any node in between the linked list.` `    ``Node* temp = node_ptr->next;` `    ``node_ptr->data = temp->data;` `    ``node_ptr->next = temp->next;` `    ``free``(temp);` `}`   `// Driver code` `int` `main()` `{` `    ``/* Start with the empty list */` `    ``Node* head = NULL;`   `    ``/* Use push() to construct below list` `    ``1->12->1->4->1 */` `    ``push(&head, 1);` `    ``push(&head, 4);` `    ``push(&head, 1);` `    ``push(&head, 12);` `    ``push(&head, 1);`   `    ``cout << ``"Before deleting \n"``;` `    ``printList(head);`   `    ``/* I m deleting the head itself.` `        ``You can check for more cases */` `    ``deleteNode(head);`   `    ``cout << ``"\nAfter deleting \n"``;` `    ``printList(head);` `    ``return` `0;` `}`   `// This code is contributed by rathbhupendra`

## C

 `// C++ program to del the node` `// in which only a single pointer` `// is known pointing to that node` `#include ` `#include ` `#include `   `/* Link list node */` `struct` `Node {` `    ``int` `data;` `    ``struct` `Node* next;` `};`   `/* Given a reference (pointer to pointer) to the head` `of a list and an int, push a new node on the front` `of the list. */` `void` `push(``struct` `Node** head_ref, ``int` `new_data)` `{` `    ``/* allocate node */` `    ``struct` `Node* new_node` `        ``= (``struct` `Node*)``malloc``(``sizeof``(``struct` `Node));`   `    ``/* put in the data  */` `    ``new_node->data = new_data;`   `    ``/* link the old list off the new node */` `    ``new_node->next = (*head_ref);`   `    ``/* move the head to point to the new node */` `    ``(*head_ref) = new_node;` `}`   `void` `printList(``struct` `Node* head)` `{` `    ``struct` `Node* temp = head;` `    ``while` `(temp != NULL) {` `        ``printf``(``"%d  "``, temp->data);` `        ``temp = temp->next;` `    ``}` `}`   `void` `deleteNode(``struct` `Node* node_ptr)` `{` `    ``// If the node to be deleted is the last ` `    ``// node of linked list` `    ``if` `(node_ptr->next == NULL)` `    ``{` `        ``free``(node_ptr);` `       `  `        ``// this will simply make the node_ptr NULL.` `        ``return``;` `    ``}` `    ``struct` `Node* temp = node_ptr->next;` `    ``node_ptr->data = temp->data;` `    ``node_ptr->next = temp->next;` `    ``free``(temp);` `}`   `// Driver code ` `int` `main()` `{` `    ``/* Start with the empty list */` `    ``struct` `Node* head = NULL;`   `    ``/* Use push() to construct below list` `    ``1->12->1->4->1  */` `    ``push(&head, 1);` `    ``push(&head, 4);` `    ``push(&head, 1);` `    ``push(&head, 12);` `    ``push(&head, 1);`   `    ``printf``(``"\n Before deleting \n"``);` `    ``printList(head);`   `    ``/* I m deleting the head itself.` `        ``You can check for more cases */` `    ``deleteNode(head);`   `    ``printf``(``"\n After deleting \n"``);` `    ``printList(head);` `    ``getchar``();` `}`

## Java

 `// Java program to del the node in ` `// which only a single pointer is ` `// known pointing to that node` `class` `LinkedList {`   `    ``static` `Node head;` `    ``static` `class` `Node {`   `        ``int` `data;` `        ``Node next;` `        ``Node(``int` `d)` `        ``{` `            ``data = d;` `            ``next = ``null``;` `        ``}` `    ``}`   `    ``void` `printList(Node node)` `    ``{` `        ``while` `(node != ``null``) {` `            ``System.out.print(node.data + ``" "``);` `            ``node = node.next;` `        ``}` `    ``}`   `    ``void` `deleteNode(Node node)` `    ``{` `        ``Node temp = node.next;` `        ``node.data = temp.data;` `        ``node.next = temp.next;` `        ``System.gc();` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``LinkedList list = ``new` `LinkedList();` `        ``list.head = ``new` `Node(``1``);` `        ``list.head.next = ``new` `Node(``12``);` `        ``list.head.next.next = ``new` `Node(``1``);` `        ``list.head.next.next.next = ``new` `Node(``4``);` `        ``list.head.next.next.next.next = ``new` `Node(``1``);`   `        ``System.out.println(``"Before Deleting "``);` `        ``list.printList(head);`   `        ``/* I m deleting the head itself.` `         ``You can check for more cases */` `        ``list.deleteNode(head);` `        ``System.out.println(``""``);` `        ``System.out.println(``"After deleting "``);` `        ``list.printList(head);` `    ``}` `}`   `// This code has been contributed by Mayank Jaiswal`

## Python3

 `# A python3 program to delete` `# the node in which only a single pointer` `# is known pointing to that node`   `# Linked list node`     `class` `Node():` `    ``def` `__init__(``self``):` `        ``self``.data ``=` `None` `        ``self``.``next` `=` `None`   `# Given a reference (pointer to pointer)` `# to the head of a list and an int,` `# push a new node on the front of the list`     `def` `push(head_ref, new_data):`   `    ``# allocate node` `    ``new_node ``=` `Node()`   `    ``# put in the data` `    ``new_node.data ``=` `new_data`   `    ``# link the old list off the new node` `    ``new_node.``next` `=` `head_ref`   `    ``# move the head to point to the new node` `    ``head_ref ``=` `new_node`   `    ``return` `head_ref`     `def` `printList(head):` `    ``temp ``=` `head` `    ``while``(temp !``=` `None``):` `        ``print``(temp.data, end``=``' '``)` `        ``temp ``=` `temp.``next`     `def` `deleteNode(node_ptr):` `    ``temp ``=` `node_ptr.``next` `    ``node_ptr.data ``=` `temp.data` `    ``node_ptr.``next` `=` `temp.``next`     `# Driver code` `if` `__name__ ``=``=` `'__main__'``:`   `    ``# Start with the empty list` `    ``head ``=` `None`   `    ``# Use push() to construct below list` `    ``# 1->12->1->4->1` `    ``head ``=` `push(head, ``1``)` `    ``head ``=` `push(head, ``4``)` `    ``head ``=` `push(head, ``1``)` `    ``head ``=` `push(head, ``12``)` `    ``head ``=` `push(head, ``1``)`   `    ``print``(``"Before deleting "``)` `    ``printList(head)`   `    ``# I'm deleting the head itself.` `    ``# You can check for more cases` `    ``deleteNode(head)`   `    ``print``(``"\nAfter deleting"``)` `    ``printList(head)`   `# This code is contributed by Yashyasvi Agarwal`

## C#

 `// C# program to del the node in` `// which only a single pointer is` `// known pointing to that node` `using` `System;`   `public` `class` `LinkedList {`   `    ``Node head;` `    ``public` `class` `Node {`   `        ``public` `int` `data;` `        ``public` `Node next;` `        ``public` `Node(``int` `d)` `        ``{` `            ``data = d;` `            ``next = ``null``;` `        ``}` `    ``}`   `    ``void` `printList(Node node)` `    ``{` `        ``while` `(node != ``null``) {` `            ``Console.Write(node.data + ``" "``);` `            ``node = node.next;` `        ``}` `    ``}`   `    ``void` `deleteNode(Node node)` `    ``{` `        ``Node temp = node.next;` `        ``node.data = temp.data;` `        ``node.next = temp.next;` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `Main()` `    ``{` `        ``LinkedList list = ``new` `LinkedList();` `        ``list.head = ``new` `Node(1);` `        ``list.head.next = ``new` `Node(12);` `        ``list.head.next.next = ``new` `Node(1);` `        ``list.head.next.next.next = ``new` `Node(4);` `        ``list.head.next.next.next.next = ``new` `Node(1);`   `        ``Console.WriteLine(``"Before Deleting "``);` `        ``list.printList(list.head);`   `        ``/* I m deleting the head itself.` `        ``You can check for more cases */` `        ``list.deleteNode(list.head);` `        ``Console.WriteLine(``""``);` `        ``Console.WriteLine(``"After deleting "``);` `        ``list.printList(list.head);` `    ``}` `}`   `/* This code contributed by PrinciRaj1992 */`

## Javascript

 ``

Output

```Before deleting
1 12 1 4 1
After deleting
12 1 4 1 ```

To make this solution work, we can mark the end node as a dummy node. But the programs/functions that are using this function should also be modified.
Try this problem in a doubly-linked list.

My Personal Notes arrow_drop_up
Recommended Articles
Page :