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

Last Updated : 29 Sep, 2024

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

**Examples:

**Input: list = 10 -> 20 -> 4 -> 30, delNode = 20
**Output: 10 -> 4 -> 30
**Explanation: Node with value 20 is deleted.

**Input: list = 1 -> 2, delNode = 1
**Output: 2
**Explanation: Node with value 1 is deleted.

Try It Yourself

**Approach:

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 idea is to **copy the data from the **next node into the given **node and then **deleting the next node.

Below is the implementation of the above approach:

C++ `

// C++ code to delete node value

#include using namespace std;

class Node { public: int data; Node* next;

Node(int val) {
    data = val;
    next = nullptr;
}

};

// Function to delete a node value when // only a pointer to that node is given void deleteNode(Node* delNode ) {

// Ensure the node to be deleted is not the last node
if (delNode  == nullptr || delNode ->next == nullptr) {
    return;  
}

// Copy data from the next node into the current node
Node* temp = delNode ->next;
delNode ->data = temp->data;

// Link current node to the node after the next node
delNode ->next = temp->next;

// Delete the next node (the one whose data was copied)
delete temp;

}

void printList(Node* head) { Node* curr = head; while (curr != nullptr) { cout << curr->data << " "; curr = curr->next; } cout << endl; }

int main() {

// Creating a linked list: 4 -> 5 -> 6 -> 7 -> 8
Node* head = new Node(4);
head->next = new Node(5);
head->next->next = new Node(6);
head->next->next->next = new Node(7);
head->next->next->next->next = new Node(8);

deleteNode(head);

printList(head);

return 0;

}

C

// C code to delete node value

#include <stdio.h> #include <stdlib.h>

struct Node { int data; struct Node* next; };

// Function to delete a node value when // only a pointer to that node is given void deleteNode(struct Node* delNode ) {

// Ensure the node to be deleted is not the last node
if (delNode  == NULL || delNode ->next == NULL) {
    return;  
}

// Copy data from the next node into the current node
struct Node* temp = delNode ->next;
delNode ->data = temp->data;

// Link current node to the node after the next node
delNode ->next = temp->next;

// Delete the next node (the one whose data was copied)
free(temp);

}

void printList(struct Node* head) { struct Node* curr = head; while (curr != NULL) { printf("%d ", curr->data); curr = curr->next; } printf("\n"); }

struct Node* createNode(int x) { struct Node* new_node = (struct Node*)malloc(sizeof(struct Node)); new_node->data = x; new_node->next = NULL; return new_node; }

int main() {

// Creating a linked list: 4 -> 5 -> 6 -> 7 -> 8
 struct Node* head = createNode(4);
head->next = createNode(5);
head->next->next = createNode(6);
head->next->next->next = createNode(7);
head->next->next->next->next = createNode(8);

deleteNode(head);

printList(head);

return 0;

}

Java

// Java code to delete node value

class Node { int data; Node next;

Node(int val) {
    data = val;
    next = null;
}

}

class GfG {

// Function to delete a node value when 
// only a pointer to that node is given
static void deleteNode(Node delNode) {
    
    // Ensure the node to be deleted is not the last node
    if (delNode == null || delNode.next == null) {
        return;
    }

    // Copy data from the next node into the current node
    Node temp = delNode.next;
    delNode.data = temp.data;

    // Link current node to the node after the next node
    delNode.next = temp.next;

    // Delete the next node (the one whose data was copied)
    temp.next = null;
}

static void printList(Node head) {
    Node curr = head;
    while (curr != null) {
        System.out.print(curr.data + " ");
        curr = curr.next;
    }
    System.out.println();
}

public static void main(String[] args) {
    
    // Creating a linked list: 4 -> 5 -> 6 -> 7 -> 8
    Node head = new Node(4);
    head.next = new Node(5);
    head.next.next = new Node(6);
    head.next.next.next = new Node(7);
    head.next.next.next.next = new Node(8);

    deleteNode(head);

    printList(head);
}

}

Python

Python code to delete node value

class Node: def init(self, data): self.data = data self.next = None

Function to delete a node value when

only a pointer to that node is given

def deleteNode(delNode):

# Ensure the node to be deleted is not the last node
if delNode is None or delNode.next is None:
    return

# Copy data from the next node into the current node
temp = delNode.next
delNode.data = temp.data

# Link current node to the node after the next node
delNode.next = temp.next

# Delete the next node (the one whose data was copied)
del temp

def printList(head): curr = head while curr: print(curr.data, end=" ") curr = curr.next print()

if name == "main":

# Creating a linked list: 4 -> 5 -> 6 -> 7 -> 8
head = Node(4)
head.next = Node(5)
head.next.next = Node(6)
head.next.next.next = Node(7)
head.next.next.next.next = Node(8)

deleteNode(head)

printList(head)

C#

// C# code to delete node value

using System;

class Node { public int data; public Node next;

public Node(int val) {
    data = val;
    next = null;
}

}

class GfG {

// Function to delete a node value when 
// only a pointer to that node is given
static void deleteNode(Node delNode) {
    
    // Ensure the node to be deleted is not the last node
    if (delNode == null || delNode.next == null) {
        return;
    }

    // Copy data from the next node into the current node
    Node temp = delNode.next;
    delNode.data = temp.data;

    // Link current node to the node after the next node
    delNode.next = temp.next;

    // Delete the next node (the one whose data was copied)
    temp.next = null;
}

static void printList(Node head) {
    Node curr = head;
    while (curr != null) {
        Console.Write(curr.data + " ");
        curr = curr.next;
    }
    Console.WriteLine();
}

static void Main(string[] args) {
    
    // Creating a linked list: 4 -> 5 -> 6 -> 7 -> 8
    Node head = new Node(4);
    head.next = new Node(5);
    head.next.next = new Node(6);
    head.next.next.next = new Node(7);
    head.next.next.next.next = new Node(8);

    deleteNode(head);

    printList(head);
}

}

JavaScript

// Javascript code to delete node value

class Node { constructor(data) { this.data = data; this.next = null; } }

// Function to delete a node value when // only a pointer to that node is given function deleteNode(delNode) {

// Ensure the node to be deleted is not the last node
if (delNode === null || delNode.next === null) {
    return;
}

// Copy data from the next node into the current node
const temp = delNode.next;
delNode.data = temp.data;

// Link current node to the node after the next node
delNode.next = temp.next;

// Delete the next node (the one whose data was copied)
temp.next = null;

}

function printList(head) { let curr = head; while (curr !== null) { console.log(curr.data + " "); curr = curr.next; } console.log(); }

// Creating a linked list: 4 -> 5 -> 6 -> 7 -> 8 let head = new Node(4); head.next = new Node(5); head.next.next = new Node(6); head.next.next.next = new Node(7); head.next.next.next.next = new Node(8);

deleteNode(head);

printList(head);

`

**Time Complexity: O(1)
**Auxiliary Space: O(1)

**Note: The described method of copying data from the next node works well for all nodes except the last one. To delete the last node, we need either:

• A pointer/reference to the previous node,
• A pointer/reference to the head node to traverse and find the previous node.