Search for a Value in Linked List in DSA Java - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output after searching for value 3?

Consider the linked list created by the code below. What will be printed when searching for the value 3?

DSA Java

class Node {
    int data;
    Node next;
    Node(int data) {
        this.data = data;
        this.next = null;
    }
}

class LinkedList {
    Node head;

    void add(int data) {
        Node newNode = new Node(data);
        if (head == null) {
            head = newNode;
        } else {
            Node current = head;
            while (current.next != null) {
                current = current.next;
            }
            current.next = newNode;
        }
    }

    boolean search(int value) {
        Node current = head;
        while (current != null) {
            if (current.data == value) {
                return true;
            }
            current = current.next;
        }
        return false;
    }
}

public class Main {
    public static void main(String[] args) {
        LinkedList list = new LinkedList();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        System.out.println(list.search(3));
    }
}

A 3

B false

C null

D true

💡 Hint

Think about whether the value 3 exists in the linked list nodes.

The search method checks each node's data. Since 3 is added to the list, the method returns true and prints it.

❓ Predict Output

intermediate

What is the output after searching for value 5?

Given the linked list below, what will be printed when searching for the value 5?

DSA Java

class Node {
    int data;
    Node next;
    Node(int data) {
        this.data = data;
        this.next = null;
    }
}

class LinkedList {
    Node head;

    void add(int data) {
        Node newNode = new Node(data);
        if (head == null) {
            head = newNode;
        } else {
            Node current = head;
            while (current.next != null) {
                current = current.next;
            }
            current.next = newNode;
        }
    }

    boolean search(int value) {
        Node current = head;
        while (current != null) {
            if (current.data == value) {
                return true;
            }
            current = current.next;
        }
        return false;
    }
}

public class Main {
    public static void main(String[] args) {
        LinkedList list = new LinkedList();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        System.out.println(list.search(5));
    }
}

A 5

B false

C null

D true

💡 Hint

Check if the value 5 was added to the list.

Since 5 was not added to the list, the search method returns false and prints it.

🧠 Conceptual

advanced

What is the time complexity of searching a value in a singly linked list?

If a singly linked list has n nodes, what is the time complexity of searching for a value in the list?

A O(1) - constant time

B O(log n) - logarithmic time

C O(n) - linear time

D O(n^2) - quadratic time

💡 Hint

Think about how many nodes you might need to check in the worst case.

In the worst case, you may need to check every node once, so the time complexity is linear O(n).

🔧 Debug

advanced

What error occurs when searching in an empty linked list?

Consider the search method below. What happens if the linked list is empty (head is null) and we call search(1)?

DSA Java

boolean search(int value) {
    Node current = head;
    while (current != null) {
        if (current.data == value) {
            return true;
        }
        current = current.next;
    }
    return false;
}

A Returns false without error

B ArrayIndexOutOfBoundsException

C NullPointerException

D Infinite loop

💡 Hint

Check what happens when current is null at the start.

If head is null, current is null, so the while loop does not run and the method returns false safely.

🚀 Application

expert

How many nodes are visited when searching for value 4 in the list 1->2->3->4->5?

Given the linked list 1 -> 2 -> 3 -> 4 -> 5 -> null, how many nodes does the search method visit when searching for the value 4?

A 4

B 3

C 5

D 1

💡 Hint

Count nodes from head until the value 4 is found.

The search visits nodes with values 1, 2, 3, and 4, so it visits 4 nodes before returning true.

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