Search for a Value in Linked List in DSA C# - Execution Trace

Concept Flow - Search for a Value in Linked List

Start at head node

↓

Check if current node is null?

Yes→Value not found, end

No↓

Compare current node value with target

↓

Return found

↓

Repeat check

Start from the head node, check each node's value. If it matches the target, stop and return found. Otherwise, move to the next node until the list ends.

Execution Sample

DSA C#

Node current = head;
while (current != null) {
  if (current.value == target) return true;
  current = current.next;
}
return false;

This code searches the linked list from head to tail for the target value, returning true if found, false otherwise.

Execution Table

Step	Operation	Current Node Value	Pointer Changes	Visual State
1	Start at head	3	current = head (3)	3 -> 7 -> 10 -> 15 -> null
2	Compare current.value with target (7)	3	current = current.next (7)	3 -> 7 -> 10 -> 15 -> null
3	Compare current.value with target (7)	7	Found target, stop	3 -> 7 -> 10 -> 15 -> null
4	Return true	-	-	Search ends, value found

💡 Value 7 found at step 3, search stops.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
current	head (3)	3	7	7	7
target	7	7	7	7	7

Key Moments - 3 Insights

Why do we check if current is null before comparing values?

Because if current is null, it means we reached the end of the list without finding the value. Checking null first prevents errors when accessing current.value. See step 2 in execution_table.

What happens if the value is not in the list?

The loop moves current through all nodes until current becomes null. Then the search ends returning false. This is shown by the exit condition in the concept flow and would appear as no match found in execution_table.

Why do we move current to current.next after each check?

To check the next node in the list. Without moving current, the loop would check the same node repeatedly causing an infinite loop. See pointer changes in steps 2 and 3.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of current at step 2?

A 7

B 10

C 3

D null

💡 Hint

Check the 'Current Node Value' column at step 2 in execution_table.

At which step does the search find the target value?

A Step 2

B Step 3

C Step 1

D Step 4

💡 Hint

Look for 'Found target' in the 'Pointer Changes' column in execution_table.

If the target was 15, what would be the pointer value after step 3?

A 10

B 15

C null

D 7

💡 Hint

Trace pointer moves in execution_table and variable_tracker for target 15.

Concept Snapshot

Search for a value in a linked list:
- Start at head node
- Check if current node is null (end)
- Compare current node's value with target
- If match, return found
- Else move to next node and repeat
- Return false if not found

Full Transcript

To search for a value in a linked list, start at the head node. Check if the current node is null; if yes, the value is not found and the search ends. If not null, compare the current node's value with the target. If they match, return true to indicate the value is found. If not, move the pointer to the next node and repeat the process. Continue until the value is found or the list ends. This process prevents errors by checking for null before accessing node values and ensures the entire list is searched.

Practice

1. What is the main purpose of searching for a value in a linked list?

easy

A. To add a new node at the end

B. To find if the value exists in the list

C. To delete the first node

D. To reverse the linked list

Solution

1. Step 1: Understand the search operation

   Searching means checking each node to see if it contains the target value.

2. Step 2: Identify the goal of searching

   The goal is to find whether the value exists anywhere in the linked list.

3. Final Answer:

   To find if the value exists in the list -> Option B

4. Quick Check:

   Search = Find value presence [OK]

Hint: Search means checking nodes for the value [OK]

Common Mistakes:

• Confusing search with insertion or deletion
• Thinking search changes the list
• Assuming search returns the node position always

2. Which of the following is the correct C# syntax to start traversing a linked list from its head node named head?

easy

A. Node current => head;

B. Node current == head;

C. Node current = head;

D. Node current <- head;

Solution

1. Step 1: Understand variable assignment syntax in C#

   To assign a reference, use single equals sign =.

2. Step 2: Check each option for correct assignment

   Node current = head; uses =, which is correct. Others use invalid operators.

3. Final Answer:

   Node current = head; -> Option C

4. Quick Check:

   Assignment uses = in C# [OK]

Hint: Use single = for assignment in C# [OK]

Common Mistakes:

• Using == instead of = for assignment
• Using invalid operators like => or <-
• Confusing assignment with comparison

3. What will be the output of the following C# code snippet?

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

Node head = new Node(5);
head.next = new Node(10);
head.next.next = new Node(15);

Node current = head;
bool found = false;
while (current != null) {
  if (current.data == 10) {
    found = true;
    break;
  }
  current = current.next;
}
Console.WriteLine(found);

medium

A. NullReferenceException

B. False

C. Compilation error

D. True

Solution

1. Step 1: Trace the linked list nodes and search loop

   The list has nodes with data 5 -> 10 -> 15. The loop checks each node's data for 10.

2. Step 2: Check when the value 10 is found

   At second node, data is 10, so found becomes true and loop breaks.

3. Final Answer:

   True -> Option D

4. Quick Check:

   Value 10 found = True [OK]

Hint: Stop loop when value found, print true [OK]

Common Mistakes:

• Forgetting to break loop after finding value
• Printing current.data instead of found
• Null pointer errors if next not checked

4. Identify the error in the following code that searches for a value in a linked list:

Node current = head;
while (current.next != null) {
  if (current.data == 20) {
    Console.WriteLine("Found");
    break;
  }
  current = current.next;
}

medium

A. It skips checking the last node

B. It causes infinite loop

C. It throws NullReferenceException immediately

D. It never enters the loop

Solution

1. Step 1: Analyze the loop condition

   The loop runs while current.next != null, so it stops before last node.

2. Step 2: Understand impact on search

   The last node's data is never checked, so search may miss the value if it's there.

3. Final Answer:

   It skips checking the last node -> Option A

4. Quick Check:

   Loop condition misses last node [OK]

Hint: Use current != null to check all nodes [OK]

Common Mistakes:

• Using current.next != null instead of current != null
• Assuming last node is checked automatically
• Not handling empty list (head null)

5. Given a linked list where nodes may contain duplicate values, how can you modify the search to return the count of occurrences of a target value x instead of just checking presence?

hard

A. Traverse all nodes, increment count when node.data == x, then return count

B. Stop at first occurrence and return 1

C. Use recursion to find only the last occurrence

D. Delete nodes with value x and return total nodes left

Solution

1. Step 1: Understand the need to count all occurrences

   Since duplicates exist, we must check every node to count all matches.

2. Step 2: Traverse entire list and count matches

   Loop through each node, increment a counter when node.data equals x, then return the count.

3. Final Answer:

   Traverse all nodes, increment count when node.data == x, then return count -> Option A

4. Quick Check:

   Count all matches by full traversal [OK]

Hint: Count matches by checking every node [OK]

Common Mistakes:

• Stopping search after first match
• Using recursion incorrectly for counting
• Modifying list during search unintentionally