Skip to content
Related Articles

Related Articles

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

Improve Article
Save Article
  • Difficulty Level : Easy
  • Last Updated : 19 Jul, 2022
Improve Article
Save Article

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

Complete Interview Preparation - GFG

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 <assert.h>
#include <bits/stdc++.h>
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 <assert.h>
#include <stdio.h>
#include <stdlib.h>
 
/* 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




<script>
// javascript program to del the node in
// which only a single pointer is
// known pointing to that node
 
    var head;
 
    class Node{
        constructor(val){
            this.data = val;
            this.next = null;
        }
    }
 
    function printList(node){
        while (node != null){
            document.write(node.data + " ");
            node = node.next;
        }
    }
 
    function deleteNode(node) {
        var temp = node.next;
        node.data = temp.data;
        node.next = temp.next;
    }
 
    // Driver code
     
        head = new Node(1);
        head.next = new Node(12);
        head.next.next = new Node(1);
        head.next.next.next = new Node(4);
        head.next.next.next.next = new Node(1);
 
        document.write("Before Deleting<br/> ");
        printList(head);
 
        /*
         * I m deleting the head itself. You can check for more cases
         */
        deleteNode(head);
        document.write("<br/>");
        document.write("After deleting<br/> ");
        printList(head);
 
// This code is contributed by todaysgaurav
</script>

Output

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

Time complexity: O(1) since performing constant operations and modifying only single pointer to delete node

Auxiliary Space: O(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
Related Articles

Start Your Coding Journey Now!