Search for a Value in Linked List in DSA C# - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to check if the linked list is empty before searching.

DSA C#

if (head == [1]) {
    return false;
}

Drag options to blanks, or click blank then click option'

Anull

B0

Chead

Dfalse

Attempts:

3 left

💡 Hint

Common Mistakes

Using 0 instead of null to check for empty list.

Checking if head equals false instead of null.

We check if head is null to know if the list is empty.

2fill in blank

medium

Complete the code to move to the next node in the linked list during search.

DSA C#

current = current.[1];

Drag options to blanks, or click blank then click option'

Aprev

Bhead

Cnext

Dvalue

Attempts:

3 left

💡 Hint

Common Mistakes

Using prev which points backward.

Using value which holds data, not the next node.

To move forward in a linked list, we use the next pointer of the current node.

3fill in blank

hard

Fix the error in the condition to compare the current node's value with the target.

DSA C#

if (current.[1] == target) {
    return true;
}

Drag options to blanks, or click blank then click option'

Anext

Bprev

Chead

Dvalue

Attempts:

3 left

💡 Hint

Common Mistakes

Comparing next or prev which are node references, not data.

Comparing head which is the start node, not current node's data.

The node's data is stored in the value property, which we compare to the target.

4fill in blank

hard

Fill both blanks to complete the while loop that searches the linked list.

DSA C#

while (current != [1] && current.[2] != target) {
    current = current.next;
}

Drag options to blanks, or click blank then click option'

Anull

Bhead

Cvalue

Dprev

Attempts:

3 left

💡 Hint

Common Mistakes

Using head instead of null to check end of list.

Comparing next or prev to target instead of value.

The loop continues while current is not null and the value is not the target.

5fill in blank

hard

Fill all three blanks to implement the full search method in the linked list.

DSA C#

public bool Search(int target) {
    Node current = [1];
    while (current != [2] && current.[3] != target) {
        current = current.next;
    }
    return current != null;
}

Drag options to blanks, or click blank then click option'

Ahead

Bnull

Cvalue

Dprev

Attempts:

3 left

💡 Hint

Common Mistakes

Starting from null instead of head.

Checking current != head instead of null.

Comparing next or prev to target instead of value.

Start from head, loop until null or found, compare value to target.

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