Search for a Value in Linked List in DSA Java - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a linked list?

A linked list is a chain of nodes where each node holds data and a link to the next node. It is like a treasure hunt where each clue leads to the next one.

beginner

How do you search for a value in a linked list?

Start at the first node and check its value. If it matches, stop. If not, move to the next node. Repeat until you find the value or reach the end.

beginner

What happens if the value is not found in the linked list?

You reach the end of the list (null) without finding the value. This means the value is not in the list.

intermediate

Why can searching a linked list be slower than searching an array?

Because you must check each node one by one from the start. Unlike arrays, you cannot jump directly to the middle.

beginner

Show the Java code snippet to search for a value in a singly linked list.

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

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

What is the first step when searching for a value in a linked list?

A Check the first node's value

B Jump to the middle node

C Check the last node's value

D Sort the list first

You always start searching from the first node in a linked list.

What does it mean if you reach a null node during search?

A Value is found

B Value is not in the list

C List is empty

D List is circular

Reaching null means you reached the end without finding the value.

Which data structure allows direct access to any element by index?

A Array

B Linked list

C Stack

D Queue

Arrays allow direct access by index, linked lists do not.

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

A O(n^2)

B O(1)

C O(log n)

D O(n)

Searching a linked list requires checking nodes one by one, so it is O(n).

In the Java search code, what does 'current = current.next' do?

A Creates a new node

B Deletes the current node

C Moves to the next node

D Checks the current node's value

It moves the pointer to the next node in the list.

Explain step-by-step how to search for a value in a singly linked list.

Think of walking through a chain checking each link.

Write a simple Java method to search for an integer in a linked list and return true if found.

Use a while loop and check current node's data.

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