Delete Node by Value in DSA Go - Deep Dive

Overview - Delete Node by Value

What is it?

Deleting a node by value means removing the first node in a linked list that contains a specific value. A linked list is a chain of nodes where each node points to the next one. When we delete a node, we change the links so the chain stays connected without the removed node. This operation helps keep the list updated by removing unwanted elements.

Why it matters

Without the ability to delete nodes by value, linked lists would grow endlessly or keep unwanted data, making programs slow or incorrect. This operation allows dynamic data management, like removing a friend from a contact list or deleting a task from a to-do list. It keeps data structures flexible and efficient in real applications.

Where it fits

Before learning this, you should understand what linked lists are and how nodes connect. After this, you can learn about more complex linked list operations like deleting by position, reversing lists, or working with doubly linked lists.

Mental Model

Core Idea

Deleting a node by value means finding the first node with that value and changing the previous node's link to skip it, removing it from the chain.

Think of it like...

Imagine a paper chain where each paper ring links to the next. To remove a ring with a certain color, you find it and then connect the previous ring directly to the next one, skipping the removed ring.

Head -> [Node1|Val] -> [Node2|Val] -> [Node3|Val] -> null

To delete Node2:
Head -> [Node1|Val] ---------> [Node3|Val] -> null
(Node2 is skipped and removed)

Build-Up - 7 Steps

1

Foundation

Understanding Linked List Structure

Concept: Learn what a linked list is and how nodes connect using pointers.

A linked list is a sequence of nodes. Each node has two parts: a value and a pointer to the next node. The list starts at a head node and ends when the next pointer is null. This structure allows easy insertion and deletion without shifting elements like in arrays.

Result

You can visualize a chain of nodes connected by pointers, starting from head and ending at null.

Understanding the basic structure of linked lists is essential because deletion depends on changing these pointers correctly.

2

Foundation

Traversing a Linked List

Concept: Learn how to move through each node to find a target value.

To find a node with a specific value, start at the head and follow each next pointer until you find the value or reach the end (null). This process is called traversal.

Result

You can locate any node by value or know if it does not exist in the list.

Traversal is the first step in deletion because you must find the node to remove before changing links.

3

Intermediate

Deleting the Head Node by Value

🤔Before reading on: If the node to delete is the head, do you think you need to change the head pointer or just the next pointer? Commit to your answer.

Concept: Deleting the first node requires updating the head pointer to the next node.

If the head node contains the value to delete, simply move the head pointer to the next node. This removes the first node from the list because nothing points to it anymore.

Result

The list starts from the second node, effectively removing the original head.

Knowing that the head pointer must be updated prevents losing access to the entire list when deleting the first node.

4

Intermediate

Deleting a Middle or Last Node by Value

🤔Before reading on: When deleting a node in the middle, do you think you remove the node directly or adjust the previous node's pointer? Commit to your answer.

Concept: To delete a node other than the head, update the previous node's next pointer to skip the target node.

Traverse the list keeping track of the previous node. When you find the node with the target value, set previous.next to current.next. This skips the current node, removing it from the chain.

Result

The node with the target value is removed, and the list remains connected without it.

Understanding pointer adjustment is key to safely removing nodes without breaking the list.

5

Intermediate

Handling Value Not Found Cases

🤔Before reading on: What should happen if the value to delete is not in the list? Should the list change or stay the same? Commit to your answer.

Concept: If the value is not found, the list remains unchanged.

Traverse the entire list. If no node matches the value, do nothing. This ensures the list stays intact and no errors occur.

Result

The list remains exactly as before, with no nodes removed.

Knowing to handle missing values prevents accidental data loss or runtime errors.

6

Advanced

Implementing Delete Node by Value in Go

🤔Before reading on: Do you think Go requires special handling for pointers when deleting nodes? Commit to your answer.

Concept: Use pointer manipulation in Go to delete nodes safely and efficiently.

In Go, define a Node struct with Value and Next pointer. To delete, check if head matches value, update head if so. Otherwise, traverse with two pointers (prev and current). When found, set prev.Next = current.Next. Handle nil pointers carefully to avoid runtime errors.

Result

A working Go function that deletes the first node with the given value from a singly linked list.

Understanding Go's pointer semantics and nil checks is crucial to avoid crashes and memory issues.

7

Expert

Edge Cases and Performance Considerations

🤔Before reading on: Do you think deleting nodes by value in a singly linked list is always fast? Commit to your answer.

Concept: Deleting by value requires traversal, which can be slow for large lists; edge cases like empty lists or multiple nodes with the same value need careful handling.

Deleting a node by value takes O(n) time because you may need to check every node. If multiple nodes have the same value, only the first is deleted. Edge cases include empty lists (do nothing), single-node lists, and deleting the last node (update previous.next to nil).

Result

You understand the limits of this operation and how to handle tricky cases safely.

Knowing the time cost and edge cases helps design better data structures or choose alternatives like doubly linked lists or hash maps for faster deletions.

Under the Hood

Internally, deleting a node by value changes the pointer of the previous node to point to the node after the one being deleted. This removes the target node from the chain, allowing it to be garbage collected or freed. The list remains connected because no other nodes point to the deleted node. The head pointer is special because it represents the start of the list and must be updated if the first node is deleted.

Why designed this way?

Linked lists use pointers to allow flexible insertion and deletion without shifting elements. Deleting by value is designed to only remove the first matching node to keep operations simple and predictable. Alternatives like doubly linked lists add complexity but allow backward traversal and easier deletion. The singly linked list deletion balances simplicity and efficiency for many use cases.

Head
 │
 ▼
[Node1|Val] -> [Node2|Val] -> [Node3|Val] -> null

To delete Node2:
Head
 │
 ▼
[Node1|Val] ---------> [Node3|Val] -> null
(Node2 is skipped and removed)

Myth Busters - 4 Common Misconceptions

Quick: Does deleting a node by value remove all nodes with that value or just the first? Commit to your answer.

Common Belief: Deleting by value removes all nodes that match the value.

Reality: Only the first node with the matching value is deleted; others remain unless deleted separately.

Why it matters: Assuming all nodes are deleted can cause bugs where unwanted nodes remain, leading to incorrect program behavior.

Quick: When deleting the head node, do you think you must traverse the list? Commit to your answer.

Common Belief: You must always traverse the list to delete any node, including the head.

Reality: If the head node matches the value, you can delete it immediately by updating the head pointer without traversal.

Why it matters: Unnecessary traversal wastes time and complicates code, reducing efficiency.

Quick: Does deleting a node by value in a singly linked list require access to the previous node? Commit to your answer.

Common Belief: You can delete a node without knowing the previous node's pointer.

Reality: You must know the previous node to update its next pointer; otherwise, you cannot remove the target node safely.

Why it matters: Ignoring this leads to broken lists or runtime errors because links are not updated correctly.

Quick: Is it safe to delete a node by value without checking if the list is empty? Commit to your answer.

Common Belief: You can delete nodes without checking if the list is empty; the code will handle it.

Reality: You must check if the list is empty (head is nil) before deletion to avoid runtime errors.

Why it matters: Skipping this check causes program crashes or undefined behavior.

Expert Zone

1

Deleting nodes in a singly linked list requires careful pointer management to avoid memory leaks or dangling pointers, especially in languages without automatic garbage collection.

2

In concurrent environments, deleting nodes safely requires synchronization to prevent race conditions and corrupted lists.

3

Optimizing deletion by caching previous nodes or using sentinel nodes can simplify edge case handling and improve code clarity.

When NOT to use

Deleting nodes by value in singly linked lists is inefficient for large lists or frequent deletions because it requires traversal. Alternatives like doubly linked lists, balanced trees, or hash tables offer faster deletion by key or position.

Production Patterns

In real systems, deletion by value is often combined with search operations and wrapped in safe APIs that handle concurrency and edge cases. Sentinel nodes or dummy heads are used to simplify deletion logic. For performance, batch deletions or lazy deletions (marking nodes as deleted) are common.

Connections

Hash Tables

Alternative data structure for fast deletion by key

Understanding linked list deletion highlights why hash tables use direct access to avoid traversal delays.

Garbage Collection

Memory management after node deletion

Knowing how deleted nodes become unreachable helps understand how garbage collectors reclaim memory automatically.

Supply Chain Management

Sequential removal of items in a chain

Deleting a node in a linked list is like removing a defective link in a supply chain, requiring rerouting connections to maintain flow.

Common Pitfalls

#1 Forgetting to update the head pointer when deleting the first node.

Wrong approach:

func deleteNode(head *Node, val int) *Node {
current := head
for current != nil {
if current.Value == val {
current = current.Next
break
}
current = current.Next
}
return head
}

Correct approach:

func deleteNode(head *Node, val int) *Node {
if head == nil {
return nil
}
if head.Value == val {
return head.Next
}
current := head
for current.Next != nil {
if current.Next.Value == val {
current.Next = current.Next.Next
break
}
current = current.Next
}
return head
}

Root cause:

Misunderstanding that the head pointer must be changed to remove the first node.

#2 Not checking if the list is empty before deletion.

Wrong approach:

func deleteNode(head *Node, val int) *Node {
current := head
for current != nil {
if current.Value == val {
// deletion logic
}
current = current.Next
}
return head
}

Correct approach:

func deleteNode(head *Node, val int) *Node {
if head == nil {
return nil
}
// deletion logic
return head
}

Root cause:

Assuming the list always has nodes leads to nil pointer dereference.

#3 Trying to delete a node without tracking the previous node.

Wrong approach:

func deleteNode(head *Node, val int) *Node {
current := head
for current != nil {
if current.Value == val {
current = current.Next
break
}
current = current.Next
}
return head
}

Correct approach:

func deleteNode(head *Node, val int) *Node {
if head == nil {
return nil
}
if head.Value == val {
return head.Next
}
prev := head
current := head.Next
for current != nil {
if current.Value == val {
prev.Next = current.Next
break
}
prev = current
current = current.Next
}
return head
}

Root cause:

Not realizing that the previous node's pointer must be updated to remove the current node.

Key Takeaways

Deleting a node by value in a linked list means finding the first node with that value and changing the previous node's pointer to skip it.

Special care is needed when deleting the head node because the head pointer must be updated to the next node.

Traversal is necessary to find the node to delete, making deletion O(n) time in the worst case.

Handling edge cases like empty lists, missing values, and single-node lists prevents runtime errors.

Understanding pointer manipulation and list structure is essential to safely and efficiently delete nodes.

Practice

1. What is the main purpose of the Delete Node by Value operation in a linked list?

easy

A. To find the position of a node with the given value

B. To remove the first node that contains the given value from the list

C. To add a new node with the given value at the end of the list

D. To reverse the linked list

Solution

1. Step 1: Understand the operation's goal

   The operation aims to remove a node that matches a specific value from the linked list.

2. Step 2: Identify the correct description

   Removing the first node with the given value matches To remove the first node that contains the given value from the list, while others describe different operations.

3. Final Answer:

   To remove the first node that contains the given value from the list -> Option B

4. Quick Check:

   Delete node by value means remove matching node [OK]

Hint: Delete node by value means remove matching node [OK]

Common Mistakes:

• Confusing deletion with insertion
• Thinking it finds position instead of deleting
• Assuming it reverses the list

2. Which of the following Go code snippets correctly deletes the first node with value 5 from a singly linked list starting at head?

easy

A. if head == nil { return head } if head.val == 5 { return head.next } curr := head for curr.next != nil && curr.next.val != 5 { curr = curr.next } if curr.next != nil { curr.next = curr.next.next } return head

B. if head == nil { return nil } curr := head for curr != nil && curr.val != 5 { curr = curr.next } if curr != nil { curr = curr.next } return head

C. if head.val == 5 { head = nil } curr := head for curr.next != nil { if curr.next.val == 5 { curr.next = nil } curr = curr.next } return head

D. curr := head for curr.next != nil { if curr.val == 5 { curr = curr.next.next } curr = curr.next } return head

Solution

1. Step 1: Check for empty list and head node value

   if head == nil { return head } if head.val == 5 { return head.next } curr := head for curr.next != nil && curr.next.val != 5 { curr = curr.next } if curr.next != nil { curr.next = curr.next.next } return head correctly returns head.next if head's value is 5, handling deletion at the start.

2. Step 2: Traverse and delete node with value 5

   if head == nil { return head } if head.val == 5 { return head.next } curr := head for curr.next != nil && curr.next.val != 5 { curr = curr.next } if curr.next != nil { curr.next = curr.next.next } return head uses a loop to find the node before the target and updates links properly; others miss this or incorrectly update pointers.

3. Final Answer:

   Option A code correctly deletes the first node with value 5 -> Option A

4. Quick Check:

   Proper pointer update and head check = if head == nil { return head } if head.val == 5 { return head.next } curr := head for curr.next != nil && curr.next.val != 5 { curr = curr.next } if curr.next != nil { curr.next = curr.next.next } return head [OK]

Hint: Check head value first, then update next pointers carefully [OK]

Common Mistakes:

• Not handling deletion when head node matches
• Incorrect pointer updates causing list break
• Skipping traversal or deleting wrong node

3. Given the linked list: 1 -> 3 -> 5 -> 7 -> 5 -> null, what will be the list after deleting the first node with value 5 using the standard delete-by-value function?

medium

A. 1 -> 3 -> 5 -> 7 -> null

B. 1 -> 3 -> 7 -> null

C. 3 -> 5 -> 7 -> 5 -> null

D. 1 -> 3 -> 7 -> 5 -> null

Solution

1. Step 1: Identify the first node with value 5

   The first 5 appears as the third node in the list (1 -> 3 -> 5).

2. Step 2: Remove that node and link previous to next

   Deleting this node links 3 directly to 7, resulting in 1 -> 3 -> 7 -> 5 -> null.

3. Final Answer:

   1 -> 3 -> 7 -> 5 -> null -> Option D

4. Quick Check:

   First 5 removed, rest unchanged = 1 -> 3 -> 7 -> 5 -> null [OK]

Hint: Delete only first matching node, keep rest intact [OK]

Common Mistakes:

• Deleting all nodes with value 5
• Removing wrong node (second 5)
• Breaking list links incorrectly

4. The following Go code attempts to delete a node by value from a singly linked list but causes a runtime panic. What is the error?

func deleteNode(head *Node, val int) *Node {
    curr := head
    for curr.next != nil {
        if curr.next.val == val {
            curr.next = curr.next.next
            break
        }
        curr = curr.next
    }
    return head
}

medium

A. It does not handle deletion if the head node contains the value

B. It causes infinite loop due to missing curr update

C. It tries to access curr.next.val without checking if curr.next is nil

D. It deletes all nodes with the value instead of just the first

Solution

1. Step 1: Analyze head node deletion case

   The code starts from head and checks curr.next, so if head itself has the value, it is not deleted.

2. Step 2: Confirm no panic cause

   The loop condition curr.next != nil prevents nil pointer dereference, so no panic from accessing curr.next.val.

3. Final Answer:

   It does not handle deletion if the head node contains the value -> Option A

4. Quick Check:

   Head node deletion missing = It does not handle deletion if the head node contains the value [OK]

Hint: Always check head node separately before looping [OK]

Common Mistakes:

• Ignoring head node deletion
• Assuming panic from nil pointer without checking
• Not breaking after deletion causing multiple deletes

5. You have a singly linked list with nodes containing values: 2 -> 4 -> 6 -> 4 -> 8 -> null. You want to delete all nodes with value 4 using a single pass delete-by-value function that deletes only the first matching node per call. How many times must you call this function to remove all 4s, and what will the list look like after all deletions?

hard

A. Call twice; final list: 2 -> 4 -> 6 -> 8 -> null

B. Call once; final list: 2 -> 6 -> 4 -> 8 -> null

C. Call twice; final list: 2 -> 6 -> 8 -> null

D. Call once; final list: 2 -> 6 -> 8 -> null

Solution

1. Step 1: Understand single pass deletion removes only first matching node

   Each call deletes only the first node with value 4 found.

2. Step 2: Count calls needed and final list

   First call removes the first 4 (second node), list becomes 2 -> 6 -> 4 -> 8 -> null. Second call removes the next 4 (third node), list becomes 2 -> 6 -> 8 -> null.

3. Final Answer:

   Call twice; final list: 2 -> 6 -> 8 -> null -> Option C

4. Quick Check:

   Two calls remove both 4s = Call twice; final list: 2 -> 6 -> 8 -> null [OK]

Hint: One call deletes one node; repeat until all removed [OK]

Common Mistakes:

• Assuming one call removes all matching nodes
• Miscounting nodes deleted per call
• Confusing node positions after deletions