Search for a Value in Linked List in DSA C# - Time & Space Complexity

Time Complexity: Search for a Value in Linked List

O(n)

Understanding Time Complexity

We want to understand how long it takes to find a value in a linked list as the list grows.

How does the search time change when the list gets bigger?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

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

public bool Search(Node head, int target) {
    Node current = head;
    while (current != null) {
        if (current.Value == target) return true;
        current = current.Next;
    }
    return false;
}
    

This code checks each node in the linked list one by one to find the target value.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Checking each node's value in the linked list.
• How many times: Up to once for every node in the list until the target is found or list ends.

How Execution Grows With Input

As the list gets longer, the search might check more nodes.

Input Size (n)	Approx. Operations
10	Up to 10 checks
100	Up to 100 checks
1000	Up to 1000 checks

Pattern observation: The number of checks grows directly with the list size.

Final Time Complexity

Time Complexity: O(n)

This means the search time grows linearly with the number of nodes in the list.

Common Mistake

[X] Wrong: "Searching a linked list is always fast because you just follow the links."

[OK] Correct: You may need to check every node, so the time grows with list size, making it slower for longer lists.

Interview Connect

Understanding this helps you explain how simple searches work and why data structure choice matters for speed.

Self-Check

"What if the linked list was sorted? How would that affect the time complexity of searching for a value?"

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