Search for a Value in Linked List in DSA Java - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to check if the linked list contains the target value.

DSA Java

while (current != null) {
    if (current.data [1] target) {
        return true;
    }
    current = current.next;
}

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

A>

B!=

C<

D==

Attempts:

3 left

💡 Hint

Common Mistakes

Using '!=' instead of '==' causes the search to fail.

Using '>' or '<' compares values incorrectly for equality.

We use '==' to check if the current node's data equals the target value.

2fill in blank

medium

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

DSA Java

current = [1];

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

Ahead

Bcurrent.next

Ctarget

Dnull

Attempts:

3 left

💡 Hint

Common Mistakes

Assigning current to head causes an infinite loop.

Assigning current to target or null stops traversal prematurely.

To move forward in the list, assign current to current.next.

3fill in blank

hard

Fix the error in the search method to return false if the value is not found.

DSA Java

public boolean search(int target) {
    Node current = head;
    while (current != null) {
        if (current.data == target) {
            return true;
        }
        current = current.next;
    }
    return [1];
}

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

Afalse

Btrue

Cnull

Dcurrent

Attempts:

3 left

💡 Hint

Common Mistakes

Returning true always causes incorrect results.

Returning null or current causes compile errors.

If the loop ends without finding the target, return false to indicate not found.

4fill in blank

hard

Fill both blanks to create a method that searches and returns the node containing the target value or null if not found.

DSA Java

public Node findNode(int target) {
    Node current = [1];
    while (current != null) {
        if (current.data == target) {
            return [2];
        }
        current = current.next;
    }
    return null;
}

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

Ahead

Btarget

Ccurrent

Dnull

Attempts:

3 left

💡 Hint

Common Mistakes

Returning target instead of the node causes type errors.

Starting from null causes no traversal.

Start from head and return the current node when the target is found.

5fill in blank

hard

Fill all three blanks to create a method that returns true if the linked list contains the target value, false otherwise.

DSA Java

public boolean contains(int target) {
    Node current = [1];
    while ([2] != null) {
        if (current.data [3] target) {
            return true;
        }
        current = current.next;
    }
    return false;
}

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

Ahead

Bcurrent

C==

D!=

Attempts:

3 left

💡 Hint

Common Mistakes

Using '!=' instead of '==' in comparison.

Looping with head instead of current causes infinite loop.

Start from head, loop while current is not null, and check if current.data equals 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 delete the first node

C. To find if the value exists in the list

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 is present or not in the linked list.

3. Final Answer:

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

4. Quick Check:

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

Hint: Search means check nodes for value presence [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 way to start traversing a linked list in Java to search for a value target?

easy

A. Node current = head; while(current != null) { if(current.data == target) break; current = current.next; }

B. Node current = null; while(current != head) { if(current.data == target) break; current = current.next; }

C. Node current = head; while(current.next != null) { if(current.data == target) break; current = current.next; }

D. Node current = head.next; while(current != null) { if(current.data == target) break; current = current.next; }

Solution

1. Step 1: Initialize traversal from head node

   Traversal must start from the head node to check all nodes including the first.

2. Step 2: Loop until current is null

   Loop continues while current is not null to cover all nodes.

3. Final Answer:

   Node current = head; while(current != null) { if(current.data == target) break; current = current.next; } -> Option A

4. Quick Check:

   Start at head and loop till null = Node current = head; while(current != null) { if(current.data == target) break; current = current.next; } [OK]

Hint: Start at head; loop while node not null [OK]

Common Mistakes:

• Starting traversal from null or head.next
• Looping until current.next is null misses last node
• Using wrong loop condition causing errors

3. What will be the output of the following code snippet if the linked list contains nodes with values 3 -> 5 -> 7 -> null and we search for value 5?

Node current = head;
boolean found = false;
while(current != null) {
  if(current.data == 5) {
    found = true;
    break;
  }
  current = current.next;
}
System.out.println(found);

medium

A. false

B. null

C. Compilation error

D. true

Solution

1. Step 1: Traverse nodes checking for value 5

   Nodes checked in order: 3 (no), 5 (yes), loop breaks and found = true.

2. Step 2: Print the found variable

   Since value 5 is found, found is true, so output is true.

3. Final Answer:

   true -> Option D

4. Quick Check:

   Value 5 found = true [OK]

Hint: If value found, print true; else false [OK]

Common Mistakes:

• Assuming output is node data instead of boolean
• Thinking loop misses the value 5
• Confusing true/false output

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 == target) {
    System.out.println("Found");
    break;
  }
  current = current.next;
}

medium

A. It causes a null pointer exception

B. It misses checking the last node

C. It never breaks the loop

D. It prints "Found" multiple times

Solution

1. Step 1: Analyze loop condition

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

2. Step 2: Check if last node is checked

   Since last node's next is null, last node is never checked for target value.

3. Final Answer:

   It misses checking the last node -> Option B

4. Quick Check:

   Loop condition excludes last node = misses last node check [OK]

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

Common Mistakes:

• Using current.next != null instead of current != null
• Assuming last node is checked
• Ignoring possibility of missing target at last node

5. Given a singly linked list where each node contains an integer, write a method to return the index (0-based) of the first occurrence of a target value. If the value is not found, return -1. Which approach correctly implements this search?

hard

A. Traverse from head, increment index each step, return index if found, else -1 after loop

B. Traverse from head, return node data if found, else return null

C. Traverse from tail backwards, return index if found, else 0

D. Traverse from head, increment index only when value matches, return index or -1

Solution

1. Step 1: Traverse from head with index counter

   Start at head, keep an index starting at 0, check each node's data.

2. Step 2: Return index if value matches, else -1 after full traversal

   If node data equals target, return current index; if not found after loop, return -1.

3. Final Answer:

   Traverse from head, increment index each step, return index if found, else -1 after loop -> Option A

4. Quick Check:

   Index search = traverse + count + return index or -1 [OK]

Hint: Count nodes from head; return index on match, else -1 [OK]

Common Mistakes:

• Returning node data instead of index
• Traversing from tail in singly linked list (not possible)
• Incrementing index only on match causing wrong count