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

Given a pointer to a node to be deleted, delete the node. Note that we don’t have pointer to head node.



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

Fast solution is to copy the data from the next node to the node to be deleted and delete the next node. Something like following.

    // Find next node using next pointer
    struct Node *temp  = node_ptr->next;

    // Copy data of next node to this node
    node_ptr->data  = temp->data;

    // Unlink next node
    node_ptr->next  = temp->next;

    // Delete next node
    free(temp);

Program:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

#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)
{
    Node* prev;
    if (node == NULL)
        return;
    else {
        while (node->next != NULL) {
            node->data = node->next->data;
            prev = node;
            node = node->next;
        }
        prev->next = NULL;
    }
}
  
/* 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 is code is contributed by rathbhupendra

chevron_right


C

filter_none

edit
close

play_arrow

link
brightness_4
code

#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)
{
    struct Node* prev;
    if (node == NULL)
        return;
    else {
        while (node->next != NULL) {
            node->data = node->next->data;
            prev = node;
            node = node->next;
        }
        prev->next = NULL;
    }
}
  
/* Drier program to test above function*/
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("Before deleting \n");
    printList(head);
  
    /* I m deleting the head itself.
        You can check for more cases */
    deleteNode(head);
  
    printf("\nAfter deleting \n");
    printList(head);
    getchar();
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

class LinkedList {
    Node head; // head of the list
  
    class Node {
        int data;
        Node next;
        Node(int d)
        {
            data = d;
            next = null;
        }
    }
  
    /* Given a reference to the head of a list and an int,
        inserts a new Node on the front of the list. */
    public void push(int new_data)
    {
        /* 1. alloc the Node and put the data */
        Node new_Node = new Node(new_data);
  
        /* 2. Make next of new Node as head */
        new_Node.next = head;
  
        /* 3. Move the head to point to new Node */
        head = new_Node;
    }
  
    /* This function prints contents of linked list 
        starting from the given Node */
    public void printList()
    {
        Node tNode = head;
        while (tNode != null) {
            System.out.print(tNode.data + " ");
            tNode = tNode.next;
        }
    }
  
    public void deleteNode(Node Node_ptr)
    {
        Node temp = Node_ptr.next;
        Node_ptr.data = temp.data;
        Node_ptr.next = temp.next;
        temp = null;
    }
  
    public static void main(String[] args)
    {
        LinkedList llist = new LinkedList();
  
        /* Use push() to construct below list
        1->12->1->4->1  */
        llist.push(1);
        llist.push(4);
        llist.push(1);
        llist.push(12);
        llist.push(1);
  
        System.out.println("Before deleting");
        llist.printList();
  
        /* I m deleting the head itself.
        You can check for more cases */
        llist.deleteNode(llist.head);
  
        System.out.println("\nAfter Deleting");
        llist.printList();
    }
}
// This code is contributed by Rajat Mishra

chevron_right


Python

filter_none

edit
close

play_arrow

link
brightness_4
code

# a class to define a node with 
# data and next pointer
class Node():
  
    # constructor to initialize a new node
    def __init__(self, val = None):
        self.data = val
        self.next = None
  
# push a node to the front of the list
def push(head, val):
  
    # allocate new node
    newnode = Node(val)
  
    # link the first node of the old list to the new node
    newnode.next = head.next
  
    # make the new node as head of the linked list 
    head.next = newnode
  
# function to print the list
def print_list(head):
  
    temp = head.next
    while(temp != None):
        print(temp.data, end = ' ')
        temp = temp.next
    print()
  
# function to delete the node
# the main logic is in this
def delete_node(node):
  
    prev = Node()
  
    if(node == None):
        return
    else:
        while(node.next != None):
            node.data = node.next.data
            prev = node
            node = node.next
  
        prev.next = None
  
  
if __name__ == '__main__':
  
    # allocate an empty header node
    # this is a node that simply points to the
    # first node in the list
    head = Node()
  
    # construct the below linked list
    # 1->12->1->4->1
    push(head, 1)
    push(head, 4)
    push(head, 1)
    push(head, 12)
    push(head, 1)
  
    print('list before deleting:')
    print_list(head)
  
    # deleting the first node in the list
    delete_node(head.next)
  
    print('list after deleting: ')
    print_list(head)
  
# This code is contributed by Adith Bharadwaj

chevron_right


Output:

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

This solution doesn’t work if the node to be deleted is the last node of the list. 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.

Exercise: Try this problem for doubly linked list.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.



My Personal Notes arrow_drop_up