Skip to main content
Talentd

Delete Node in a Linked List - Solution & Explanation

MediumLinked List12 min readAsked at: Amazon, Microsoft, Apple +7
Practice this problem

Problem Statement

There is a singly-linked list head and we want to delete a node node in it.

You are given the node to be deleted node. You will not be given access to the first node of head.

All the values of the linked list are unique, and it is guaranteed that the given node node is not the last node in the linked list.

Delete the given node. Note that by deleting the node, we do not mean removing it from memory. We mean:

  • The value of the given node should not exist in the linked list.
  • The number of nodes in the linked list should decrease by one.
  • All the values before node should be in the same order.
  • All the values after node should be in the same order.

Custom testing:

  • For the input, you should provide the entire linked list head and the node to be given node. node should not be the last node of the list and should be an actual node in the list.
  • We will build the linked list and pass the node to your function.
  • The output will be the entire list after calling your function.

 

Example 1:

Input: head = [4,5,1,9], node = 5
Output: [4,1,9]
Explanation: You are given the second node with value 5, the linked list should become 4 -> 1 -> 9 after calling your function.

Example 2:

Input: head = [4,5,1,9], node = 1
Output: [4,5,9]
Explanation: You are given the third node with value 1, the linked list should become 4 -> 5 -> 9 after calling your function.

 

Constraints:

  • The number of the nodes in the given list is in the range [2, 1000].
  • -1000 <= Node.val <= 1000
  • The value of each node in the list is unique.
  • The node to be deleted is in the list and is not a tail node.

Approach Overview

Problem Overview: You’re given a reference to a node inside a singly linked list, not the head. The task is to delete that node from the list while keeping the rest of the list intact. The constraint is the key challenge: without access to the previous node, you can’t perform the usual pointer update.

Approach 1: Copy and Bypass (O(1) time, O(1) space)

This trick avoids needing the previous node. Copy the value from the next node into the current node using node.val = node.next.val. Then bypass the next node by updating the pointer: node.next = node.next.next. The original "next" node effectively disappears from the list. This works because the node to delete is guaranteed not to be the tail, so node.next always exists. The structure of the linked list remains valid and the deletion appears as if the original node was removed.

Approach 2: Utilize Two Pointers (O(n) time, O(1) space)

If the head of the list is available, you can traverse the list to locate the previous node. Use two pointers: one iterating through the list and another tracking the previous node. When the current pointer matches the node that needs deletion, update prev.next = curr.next to unlink it. This is the standard deletion method in a singly linked list. The traversal introduces linear time complexity, similar to many two pointer scanning patterns where one pointer follows another through the structure.

Recommended for interviews: The expected solution is the Copy and Bypass approach. Interviewers want to see whether you recognize the constraint that the previous node is unavailable. Copying the next node’s value and skipping it demonstrates a deep understanding of pointer manipulation in linked lists. The traversal approach shows baseline knowledge, but the O(1) trick is the real signal of problem-solving skill.

Approach 1: Copy and Bypass

This approach leverages the fact that we have access to the node to be deleted and that deletion does not mean removing from memory but rather bypassing this node.

By copying the value from the next node to the node to be deleted and rearranging the pointers, we can effectively 'delete' the node without needing access to the head of the list.

In C, we access the next node, copy its value into the current node, and link to its next pointer. Finally, we free the memory of the next node to clean up.

Code

CC++JavaPythonC#JavaScript

C

C++

Java

Python

C#

JavaScript

Complexity

Time Complexity: O(1) since we're performing constant-time operations.

Space Complexity: O(1) because we aren't using any auxiliary data structures.

Try this approach in the editor →

Approach 2: Utilize Two Pointers

This approach uses two pointers to manage nodes, allowing for a genuine swap and linkage manipulation. It reinforces the conceptual understanding of linked list pointer adjustments.

Note: The fundamentals are the same as we still replace and link to carry out the 'deletion'.

In C, we manage two pointers internally to achieve the same result, illustrating the necessity to understand pointer accessibility and connectivity.

Code

CC++JavaPythonC#JavaScript

C

C++

Java

Python

C#

JavaScript

Complexity

Time Complexity: O(1), never fluctuating beyond direct node handling.

Space Complexity: O(1), not utilizing external structures.

Try this approach in the editor →

Approach 3: Node assignment

We can replace the value of the current node with the value of the next node, and then delete the next node. This can achieve the purpose of deleting the current node.

Time complexity O(1), space complexity O(1).

Code

PythonJavaC++GoTypeScriptJavaScriptC#C

Python

Java

C++

Go

TypeScript

JavaScript

C#

C

Try this approach in the editor →

Complexity Comparison

ApproachComplexity
Copy and Bypass

Time Complexity: O(1) since we're performing constant-time operations.

Space Complexity: O(1) because we aren't using any auxiliary data structures.

Utilize Two Pointers

Time Complexity: O(1), never fluctuating beyond direct node handling.

Space Complexity: O(1), not utilizing external structures.

Node assignment—

Detailed Complexity Analysis

ApproachTimeSpaceWhen to Use
Copy and BypassO(1)O(1)When only the target node is given and it is guaranteed not to be the tail
Two Pointers TraversalO(n)O(1)When the head pointer is available and you want the standard deletion logic

Video Solution

Delete Node in a Linked List | Can you solve it ? • take U forward • 132,816 views views

Watch 9 more video solutions →

Frequently Asked Questions

Is Delete Node in a Linked List easy or hard?
Delete Node in a Linked List is labeled Medium on LeetCode, but many developers find it tricky because the node to delete is given without the head. Recognizing the copy-and-bypass trick is the key insight.
Delete Node in a Linked List Python/Java solution
In Python or Java, the implementation is identical in logic: copy the next node's value and update the pointer to skip it. This constant-time solution modifies the current node rather than physically removing it from memory.
How to solve Delete Node in a Linked List in O(1)?
Use the copy-and-bypass trick. Assign the next node's value to the current node using node.val = node.next.val, then update node.next = node.next.next. This effectively removes the next node while making the current node appear deleted.
What is the best approach for Delete Node in a Linked List?
The optimal approach is the Copy and Bypass technique with O(1) time and O(1) space complexity. Copy the value from the next node into the given node, then update the next pointer to skip the next node. This works because the node to delete is guaranteed not to be the tail.
Is Delete Node in a Linked List asked at Google/Amazon/Meta?
Delete Node in a Linked List is a classic pointer manipulation problem frequently asked in technical interviews at companies like Google, Amazon, and Meta. It tests understanding of linked list structure and edge cases involving node references.
What data structure is used in Delete Node in a Linked List?
The problem uses a singly linked list. Each node contains a value and a pointer to the next node. The challenge revolves around pointer manipulation without access to the previous node in the list.
What is the time complexity of Delete Node in a Linked List?
The optimal solution runs in O(1) time because it performs constant operations: copying a value and updating a pointer. A traditional traversal approach would take O(n) time since you must iterate through the linked list to find the previous node.

Ready to solve this problem?

Practice Delete Node in a Linked List with our built-in code editor and test cases.

Practice on FleetCode
Previous

Delete Nodes From Linked List Present in Array

Next

Remove Linked List Elements