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

↓

Is current node null?

Yes→Value not found, stop

No↓

Check if current node value == target

Yes↓

Value found, stop

No↓

Move to next node

↓

Is current node null?

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

Execution Sample

DSA C++

struct Node {
  int data;
  Node* next;
};

bool search(Node* head, int target) {
  Node* current = head;
  while (current != nullptr) {
    if (current->data == target) return true;
    current = current->next;
  }
  return false;
}

This code searches for a target value in a singly linked list by traversing nodes from head to end.

Execution Table

Step	Operation	Current Node Value	Pointer Changes	Visual State
1	Start at head	3	current = head	3 -> 7 -> 10 -> 15 -> null
2	Check if current->data == 7	3	current unchanged	3 -> 7 -> 10 -> 15 -> null
3	Move to next node	3	current = current->next	3 -> 7 -> 10 -> 15 -> null
4	Check if current->data == 7	7	current unchanged	3 -> 7 -> 10 -> 15 -> null
5	Value found, return true	7	stop traversal	3 -> 7 -> 10 -> 15 -> null

💡 Value 7 found at step 4, search stops.

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	Final
current	3 (head)	3	7	7	7
search result	undefined	undefined	undefined	true	true

Key Moments - 3 Insights

Why do we check current != nullptr before accessing current->data?

Because if current is nullptr (end of list), accessing current->data causes error. See execution_table step 2 where current is valid before checking data.

What happens if the value is not in the list?

The loop continues until current becomes nullptr (end). Then function returns false. This is shown by exit condition in concept_flow and would appear as 'Value not found' if no match.

Why do we move current to current->next after each check?

To check the next node in the list. Without moving, we would check the same node repeatedly. See execution_table step 3 where current moves from 3 to 7.

Visual Quiz - 3 Questions

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

A 3

B 10

C 7

D null

💡 Hint

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

At which step does the search stop because the value is found?

A Step 4

B Step 2

C Step 3

D Step 5

💡 Hint

Look for 'Value found' in the Operation column of execution_table.

If the target value was 15 instead of 7, what would happen to the pointer changes?

A current would stop at 7

B current would move through nodes 3, 7, 10, then 15

C current would never move from head

D current would become null immediately

💡 Hint

Think about how current moves to next node each step until value is found or list ends.

Concept Snapshot

Search in Linked List:
- Start at head node
- While current node not null:
  - Check if current node's value == target
  - If yes, return true
  - Else, move to next node
- If end reached, return false

Full Transcript

To search for a value in a linked list, start at the head node. Check if the current node's value matches the target. If it does, stop and return true. If not, move to the next node and repeat. If you reach the end of the list (null) without finding the value, return false. This process ensures every node is checked until the value is found or the list ends.

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 of the list

B. To find if a specific value exists in the list

C. To delete the first node of the list

D. To reverse the order of nodes in the list

Solution

1. Step 1: Understand the search operation

   Searching in a linked list means checking each node to see if it contains the value we want.

2. Step 2: Identify the goal of searching

   The goal is to find whether the value exists anywhere in the list, not to modify the list.

3. Final Answer:

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

4. Quick Check:

   Search means find value presence = To find if a specific value exists in the list [OK]

Hint: Search means check each node for the value [OK]

Common Mistakes:

• Confusing search with insertion or deletion
• Thinking search changes the list
• Assuming search reverses the list

2. Which of the following is the correct syntax to start traversing a singly linked list in C++?

easy

A. Node* current = new Node();

B. Node current = head;

C. Node current = new Node();

D. Node* current = head;

Solution

1. Step 1: Understand pointer usage in linked lists

   In C++, linked list nodes are accessed via pointers, so we use a pointer variable to traverse.

2. Step 2: Identify correct pointer initialization

   We set a pointer 'current' to point to the head node to start traversal: Node* current = head;

3. Final Answer:

   Node* current = head; -> Option D

4. Quick Check:

   Use pointer to start traversal = Node* current = head; [OK]

Hint: Use pointer to traverse linked list starting at head [OK]

Common Mistakes:

• Using object instead of pointer for traversal
• Creating a new node instead of using existing head
• Not initializing traversal pointer correctly

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

struct Node {
  int data;
  Node* next;
};

Node* head = new Node{10, nullptr};
head->next = new Node{20, nullptr};
head->next->next = new Node{30, nullptr};

Node* current = head;
int searchValue = 20;
bool found = false;
while (current != nullptr) {
  if (current->data == searchValue) {
    found = true;
    break;
  }
  current = current->next;
}
if (found) std::cout << "Value found";
else std::cout << "Value not found";

medium

A. Value not found

B. Compilation error

C. Value found

D. Runtime error

Solution

1. Step 1: Trace the linked list nodes and values

   The list has nodes with values 10 -> 20 -> 30. We search for 20.

2. Step 2: Check the search loop logic

   The loop checks each node's data. When it reaches node with 20, found becomes true and loop breaks.

3. Final Answer:

   Value found -> Option C

4. Quick Check:

   20 exists in list, so output = "Value found" [OK]

Hint: Check each node's data until match or end [OK]

Common Mistakes:

• Forgetting to update current pointer
• Using wrong comparison operator
• Not breaking loop after finding value

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

Node* current = head;
int searchValue = 15;
while (current->next != nullptr) {
  if (current->data == searchValue) {
    std::cout << "Found";
    break;
  }
  current = current->next;
}
if (current == nullptr) std::cout << "Not Found";

medium

A. The loop condition skips checking the last node

B. The searchValue variable is not initialized

C. The current pointer is not updated inside the loop

D. The output statements are missing semicolons

Solution

1. Step 1: Analyze the loop condition

   The loop runs while current->next is not nullptr, so it stops before the last node.

2. Step 2: Understand impact on search

   The last node's data is never checked, so if the value is there, it will be missed.

3. Final Answer:

   The loop condition skips checking the last node -> Option A

4. Quick Check:

   Loop must check all nodes including last [OK]

Hint: Loop on current != nullptr to check all nodes [OK]

Common Mistakes:

• Using current->next != nullptr instead of current != nullptr
• Not checking last node's data
• Incorrectly handling nullptr checks

5. You want to search for a value in a singly linked list and return its position (1-based index). Which approach correctly implements this?

int searchPosition(Node* head, int value) {
  int pos = 1;
  Node* current = head;
  while (current != nullptr) {
    if (current->data == value) return pos;
    current = current->next;
    pos++;
  }
  return -1;
}

hard

A. Returns the position of value or -1 if not found

B. Returns true if value found, false otherwise

C. Returns the last node's data always

D. Returns 0 if value is found at head

Solution

1. Step 1: Understand the function logic

   The function starts position at 1 and traverses nodes, checking data against value.

2. Step 2: Check return values

   If value matches, it returns current position; if not found, returns -1.

3. Final Answer:

   Returns the position of value or -1 if not found -> Option A

4. Quick Check:

   Function returns index or -1 if missing [OK]

Hint: Return index on match, else -1 after full traversal [OK]

Common Mistakes:

• Returning boolean instead of position
• Starting position count at 0 instead of 1
• Not returning -1 when value not found