Delete Node by Value in DSA C# - Build from Scratch

Delete Node by Value

📖 Scenario: Imagine you have a simple list of tasks to do, and you want to remove a specific task by its name.

🎯 Goal: You will build a singly linked list of tasks and write code to delete a node by its value (task name).

📋 What You'll Learn

Create a singly linked list with exact task names

Add a variable to hold the task name to delete

Write a method to delete the node with the given task name

Print the linked list after deletion

💡 Why This Matters

🌍 Real World

Linked lists are used in many applications like task scheduling, undo functionality, and managing playlists where items need to be added or removed dynamically.

💼 Career

Understanding how to manipulate linked lists is important for software development roles that involve data structure optimization and memory management.

1

Create the linked list with tasks

Create a singly linked list with nodes containing these exact task names in order: "Laundry", "Groceries", "Homework", "Exercise", "Call Mom". Use the class Node with a string field Value and a Node field Next. Create a variable head that points to the first node.

DSA C#

// Create the linked list nodes and link them
// Your code here

Hint

Start by creating the first node with "Laundry". Then link each next node using the Next property.

2

Add the task name to delete

Create a variable called taskToDelete and set it to the string "Homework".

DSA C#

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

Node head = new Node("Laundry");
head.Next = new Node("Groceries");
head.Next.Next = new Node("Homework");
head.Next.Next.Next = new Node("Exercise");
head.Next.Next.Next.Next = new Node("Call Mom");

// Create a variable taskToDelete with value "Homework"
// Your code here

Hint

Use string taskToDelete = "Homework"; to store the task name you want to remove.

3

Write the method to delete the node by value

Write a method called DeleteNodeByValue that takes Node head and string value as parameters and returns the new head of the list after deleting the first node with Value equal to value. Handle the case where the node to delete is the head. Use a while loop with variables current and previous to find and remove the node.

DSA C#

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

Node head = new Node("Laundry");
head.Next = new Node("Groceries");
head.Next.Next = new Node("Homework");
head.Next.Next.Next = new Node("Exercise");
head.Next.Next.Next.Next = new Node("Call Mom");

string taskToDelete = "Homework";

// Write DeleteNodeByValue method below
// Your code here

Hint

Check if the head node has the value to delete. If yes, return head.Next. Otherwise, loop through the list with current and previous to find the node and remove it by changing previous.Next.

4

Print the linked list after deletion

Call DeleteNodeByValue with head and taskToDelete, assign the result back to head. Then use a while loop with a variable current starting at head to print each node's Value followed by " -> ". After the loop, print "null".

DSA C#

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

Node head = new Node("Laundry");
head.Next = new Node("Groceries");
head.Next.Next = new Node("Homework");
head.Next.Next.Next = new Node("Exercise");
head.Next.Next.Next.Next = new Node("Call Mom");

string taskToDelete = "Homework";

Node DeleteNodeByValue(Node head, string value)
{
    if (head == null) return null;
    if (head.Value == value) return head.Next;

    Node current = head.Next;
    Node previous = head;

    while (current != null)
    {
        if (current.Value == value)
        {
            previous.Next = current.Next;
            return head;
        }
        previous = current;
        current = current.Next;
    }
    return head;
}

// Call DeleteNodeByValue and print the list
// Your code here

Hint

Call DeleteNodeByValue with head and taskToDelete. Then loop through the list starting at head and print each node's Value followed by " -> ". Finally, print "null".

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