Delete Node by Value in DSA C#

Mental Model

To remove a node with a specific value, find it by walking through the list and then skip it by changing the previous node's pointer.

Analogy: Imagine a chain of paper clips linked together. To remove one clip with a certain color, you find it and then link the clip before it directly to the clip after it, skipping the one you want to remove.

head -> 1 -> 2 -> 3 -> 4 -> null

Dry Run Walkthrough

Input: list: 1 -> 2 -> 3 -> 4, delete value 3

Goal: Remove the node containing value 3 from the list

Step 1: Check if head node has value 3

head -> [1] -> 2 -> 3 -> 4 -> null

Why: We must check if the first node is the one to delete

Step 2: Move to next node since head is not 3

head -> 1 -> [2] -> 3 -> 4 -> null

Why: Keep searching for the node with value 3

Step 3: Found node with value 3 after current node 2

head -> 1 -> 2 -> [3] -> 4 -> null

Why: We found the node to delete

Step 4: Change node 2's next pointer to skip node 3 and point to node 4

head -> 1 -> 2 -> 4 -> null

Why: Skipping node 3 removes it from the list

Result:

head -> 1 -> 2 -> 4 -> null

Annotated Code

DSA C#

using System;

public class Node
{
    public int Value;
    public Node Next;

    public Node(int value)
    {
        Value = value;
        Next = null;
    }
}

public class LinkedList
{
    public Node Head;

    public LinkedList()
    {
        Head = null;
    }

    public void Append(int value)
    {
        if (Head == null)
        {
            Head = new Node(value);
            return;
        }
        Node current = Head;
        while (current.Next != null)
        {
            current = current.Next;
        }
        current.Next = new Node(value);
    }

    public void DeleteByValue(int value)
    {
        // If list is empty, nothing to delete
        if (Head == null) return;

        // If head node holds the value to delete
        if (Head.Value == value)
        {
            Head = Head.Next; // Remove head by moving it forward
            return;
        }

        Node current = Head;
        // Traverse list to find node before the one to delete
        while (current.Next != null && current.Next.Value != value)
        {
            current = current.Next; // advance current
        }

        // If node to delete found, skip it
        if (current.Next != null && current.Next.Value == value)
        {
            current.Next = current.Next.Next; // bypass node
        }
    }

    public void PrintList()
    {
        Node current = Head;
        while (current != null)
        {
            Console.Write(current.Value);
            if (current.Next != null) Console.Write(" -> ");
            current = current.Next;
        }
        Console.WriteLine(" -> null");
    }
}

class Program
{
    static void Main()
    {
        LinkedList list = new LinkedList();
        list.Append(1);
        list.Append(2);
        list.Append(3);
        list.Append(4);

        list.DeleteByValue(3);
        list.PrintList();
    }
}

if (Head == null) return;

stop if list is empty -- no nodes to delete

if (Head.Value == value) { Head = Head.Next; // Remove head by moving it forward return; }

if head node matches value, remove it by moving head pointer forward

while (current.Next != null && current.Next.Value != value) { current = current.Next; // advance current }

walk through list to find node before the one to delete

if (current.Next != null && current.Next.Value == value) { current.Next = current.Next.Next; // bypass node }

skip the node with target value by linking previous node to next node

Output

1 -> 2 -> 4 -> null

Complexity Analysis

Time: O(n) because in the worst case we traverse all nodes once to find the value

Space: O(1) because we only use a few pointers and no extra data structures

vs Alternative: Compared to rebuilding a new list without the value (which is O(n) time and O(n) space), this method removes the node in place with constant extra space

Edge Cases

empty list

function returns immediately without error

DSA C#

if (Head == null) return;

value to delete is at head

head pointer moves to next node, removing the first node

DSA C#

if (Head.Value == value)
{
    Head = Head.Next; // Remove head by moving it forward
    return;
}

value not found in list

list remains unchanged after traversal

DSA C#

while (current.Next != null && current.Next.Value != value)
{
    current = current.Next; // advance current
}

When to Use This Pattern

When you need to remove an item from a linked list by its value, look for the pattern of finding the node before it and changing pointers to skip it.

Common Mistakes

Mistake: Not handling deletion of the head node separately
Fix: Add a check for head node value before traversing the list

Mistake: Trying to delete a node without checking if it exists (null pointer errors)
Fix: Check if current.Next is not null before accessing its value

Summary

Deletes the first node with a given value from a singly linked list.

Use when you want to remove a specific value from a linked list efficiently.

The key is to find the node before the target and change its next pointer to skip the target node.

Practice

1. What does the operation Delete Node by Value do in a linked list?

easy

A. Adds a new node with the given value at the end of the list

B. Finds the node with the given value and returns it without removing

C. Removes the first node that contains the given value from the list

D. Reverses the linked list

Solution

1. Step 1: Understand the operation

   Deleting a node by value means searching for the first node that matches the value and removing it from the linked list.

2. Step 2: Compare options

   Only Removes the first node that contains the given value from the list describes removing the first node with the given value. Others describe adding, finding without removing, or reversing, which are different operations.

3. Final Answer:

   Removes the first node that contains the given value from the list -> Option C

4. Quick Check:

   Delete Node by Value = Remove first matching node [OK]

Hint: Deleting by value removes first matching node only [OK]

Common Mistakes:

• Confusing deletion by value with adding a node
• Thinking it removes all nodes with that value
• Assuming it reverses the list

2. Which of the following is the correct C# syntax to delete a node by value from a singly linked list?

easy

A. void DeleteNodeByValue(int value) { /* code */ }

B. public void DeleteNode(int value) { /* code */ }

C. public int DeleteNode(int value) { /* code */ }

D. DeleteNode(int value) => { /* code */ }

Solution

1. Step 1: Check method signature conventions in C#

   In C#, methods usually have an access modifier like 'public' and a return type. Deleting a node usually returns void.

2. Step 2: Analyze options

   public void DeleteNode(int value) { /* code */ } uses 'public void DeleteNode(int value)', which is correct. void DeleteNodeByValue(int value) { /* code */ } misses access modifier. public int DeleteNode(int value) { /* code */ } returns int which is uncommon here. DeleteNode(int value) => { /* code */ } uses invalid lambda syntax for method.

3. Final Answer:

   public void DeleteNode(int value) { /* code */ } -> Option B

4. Quick Check:

   Correct method signature = public void DeleteNode(int value) { /* code */ } [OK]

Hint: Use public void method with parameter for deletion [OK]

Common Mistakes:

• Omitting access modifier
• Using wrong return type
• Incorrect method syntax

3. Given the linked list: 10 -> 20 -> 30 -> 40 -> null, what is the list after deleting the node with value 30 using the DeleteNodeByValue method?

medium

A. 10 -> 20 -> 40 -> null

B. 10 -> 20 -> 30 -> 40 -> null

C. 20 -> 30 -> 40 -> null

D. 10 -> 30 -> 40 -> null

Solution

1. Step 1: Identify the node to delete

   The node with value 30 is the third node in the list.

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

   After deleting 30, the node with value 20 points directly to 40, so the list becomes 10 -> 20 -> 40 -> null.

3. Final Answer:

   10 -> 20 -> 40 -> null -> Option A

4. Quick Check:

   Deleted 30, list skips it [OK]

Hint: Remove node and link previous to next node [OK]

Common Mistakes:

• Not updating links after deletion
• Deleting wrong node
• Leaving deleted node in list

4. Consider this code snippet to delete a node by value in a singly linked list:

public void DeleteNode(int value) {
  Node current = head;
  Node previous = null;
  while (current != null && current.data != value) {
    previous = current;
    current = current.next;
  }
  if (current == null) return;
  previous.next = current.next;
}

What error will occur when deleting the head node?

medium

A. Compilation error due to missing return type

B. No error, deletion works fine

C. Infinite loop because current never changes

D. NullReferenceException because previous is null when deleting head

Solution

1. Step 1: Analyze deletion of head node

   If the node to delete is head, previous is still null because loop never runs.

2. Step 2: Check assignment previous.next = current.next

   Since previous is null, trying to access previous.next causes NullReferenceException.

3. Final Answer:

   NullReferenceException because previous is null when deleting head -> Option D

4. Quick Check:

   Deleting head needs special case to avoid null error [OK]

Hint: Handle head deletion separately to avoid null errors [OK]

Common Mistakes:

• Not checking if node to delete is head
• Assuming previous is never null
• Ignoring null pointer exceptions

5. You have a singly linked list: 5 -> 10 -> 15 -> 20 -> 25 -> null. You want to delete the node with value 5 (head), then delete the node with value 20. What will the list look like after these two deletions?

hard

A. 10 -> 15 -> 25 -> null

B. 5 -> 10 -> 15 -> 25 -> null

C. 10 -> 15 -> 20 -> 25 -> null

D. 15 -> 25 -> null

Solution

1. Step 1: Delete head node with value 5

   Removing head means head moves to next node, so list becomes 10 -> 15 -> 20 -> 25 -> null.

2. Step 2: Delete node with value 20

   Find node 20 and remove it by linking 15 to 25, resulting in 10 -> 15 -> 25 -> null.

3. Final Answer:

   10 -> 15 -> 25 -> null -> Option A

4. Quick Check:

   Deleted head and middle node correctly [OK]

Hint: Delete head first, then link previous to next for others [OK]

Common Mistakes:

• Not updating head after deleting first node
• Not linking nodes correctly after deletion
• Deleting wrong nodes