Search for a Value in Linked List in DSA C - Build from Scratch

Search for a Value in Linked List

📖 Scenario: You are working with a simple linked list that stores numbers. You want to find out if a certain number is present in the list.

🎯 Goal: Build a program that creates a linked list, sets a target number to search for, searches the linked list for that number, and prints whether the number was found or not.

📋 What You'll Learn

Create a linked list with exactly three nodes containing the values 10, 20, and 30 in that order

Create an integer variable called target and set it to 20

Write a function called search that takes the head of the linked list and the target value, and returns 1 if found, 0 otherwise

Print Found if the target is in the list, otherwise print Not Found

💡 Why This Matters

🌍 Real World

Searching in linked lists is a basic operation used in many software systems where data is stored dynamically, such as in memory management or real-time data processing.

💼 Career

Understanding linked list traversal and search is fundamental for software developers working with low-level data structures, embedded systems, or performance-critical applications.

1

Create the linked list with three nodes

Create a struct called Node with an integer data and a pointer to Node called next. Then create three nodes named node1, node2, and node3. Set their data to 10, 20, and 30 respectively. Link node1.next to node2, node2.next to node3, and node3.next to NULL. Finally, create a pointer head that points to node1.

DSA C

# Define the Node struct and create three linked nodes
# Your code here

Hint

Remember to define the struct before main. Then create three variables of type struct Node. Set their data and link their next pointers properly.

2

Set the target value to search

Inside main, create an integer variable called target and set it to 20.

DSA C

#include 
#include 

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

int main() {
    struct Node node1, node2, node3;
    node1.data = 10;
    node1.next = &node2;
    node2.data = 20;
    node2.next = &node3;
    node3.data = 30;
    node3.next = NULL;

    struct Node* head = &node1;

    // Create target variable
    # Your code here

    return 0;
}

Hint

Just declare int target = 20; inside main.

3

Write the search function

Write a function called search that takes two parameters: a pointer to Node called head and an integer target. The function should return 1 if target is found in the linked list, otherwise return 0. Use a while loop to traverse the list.

DSA C

#include 
#include 

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

// Write search function here

int main() {
    struct Node node1, node2, node3;
    node1.data = 10;
    node1.next = &node2;
    node2.data = 20;
    node2.next = &node3;
    node3.data = 30;
    node3.next = NULL;

    struct Node* head = &node1;

    int target = 20;

    // Your code here

    return 0;
}

Hint

Use a while loop to check each node's data. Return 1 if found, else 0 after the loop.

4

Call search and print the result

Inside main, call the search function with head and target. If it returns 1, print Found. Otherwise, print Not Found.

DSA C

#include 
#include 

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

int search(struct Node* head, int target) {
    struct Node* current = head;
    while (current != NULL) {
        if (current->data == target) {
            return 1;
        }
        current = current->next;
    }
    return 0;
}

int main() {
    struct Node node1, node2, node3;
    node1.data = 10;
    node1.next = &node2;
    node2.data = 20;
    node2.next = &node3;
    node3.data = 30;
    node3.next = NULL;

    struct Node* head = &node1;

    int target = 20;

    // Call search and print result
    # Your code here

    return 0;
}

Hint

Use if (search(head, target)) to check the result. Print Found or Not Found accordingly.

Practice

1. What is the main purpose of searching for a value in a linked list?

easy

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

B. To add a new node at the end of 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 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 linked list.

3. Final Answer:

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

4. Quick Check:

   Search = Find value in list [OK]

Hint: Search means look for a value in nodes [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 searching a linked list in C?

easy

A. Node* current = head; while(current != NULL) { if(current->data == value) break; current = current->next; }

B. Node* current = NULL; while(current != head) { if(current->data == value) break; current = current->next; }

C. Node* current = head; while(current->next != NULL) { if(current->data == value) break; current = current->next; }

D. Node* current = head; for(int i=0; inext; }

Solution

1. Step 1: Initialize pointer to head

   We start searching from the head node, so current = head is correct.

2. Step 2: Traverse until end or value found

   Loop continues while current is not NULL, checking each node's data.

3. Final Answer:

   Node* current = head; while(current != NULL) { if(current->data == value) break; current = current->next; } -> Option A

4. Quick Check:

   Start at head and loop till NULL [OK]

Hint: Start at head, loop until NULL or value found [OK]

Common Mistakes:

• Initializing current to NULL instead of head
• Looping until current->next is NULL misses last node
• Using for loop with value as count incorrectly

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

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

int search(Node* head, int value) {
  Node* current = head;
  while(current != NULL) {
    if(current->data == value) {
      return 1;
    }
    current = current->next;
  }
  return 0;
}

int main() {
  Node n3 = {10, NULL};
  Node n2 = {7, &n3};
  Node n1 = {3, &n2};
  int found = search(&n1, 7);
  printf("%d", found);
  return 0;
}

medium

A. Compilation error

B. 0

C. 7

D. 1

Solution

1. Step 1: Trace the search function

   The function checks each node's data: 3 (no), 7 (yes), so it returns 1 immediately.

2. Step 2: Understand main output

   Main prints the returned value, which is 1, indicating value found.

3. Final Answer:

   1 -> Option D

4. Quick Check:

   Value found = 1 [OK]

Hint: Returns 1 if found, else 0 [OK]

Common Mistakes:

• Expecting the value itself to be printed
• Confusing return 1 with return 0
• Thinking code causes compilation error

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

int search(Node* head, int value) {
  Node* current = head;
  while(current->next != NULL) {
    if(current->data == value) {
      return 1;
    }
    current = current->next;
  }
  return 0;
}

medium

A. The function returns 1 even if value is not found

B. The pointer current is not initialized

C. The loop condition misses checking the last node

D. The function should return the node pointer instead of int

Solution

1. Step 1: Analyze loop condition

   The loop runs while current->next != NULL, so it stops before last node.

2. Step 2: Consequence of condition

   The last node's data is never checked, so search may miss value at last node.

3. Final Answer:

   The loop condition misses checking the last node -> Option C

4. Quick Check:

   Loop condition excludes last node [OK]

Hint: Loop until current != NULL to check all nodes [OK]

Common Mistakes:

• Using current->next != NULL instead of current != NULL
• Assuming last node is checked automatically
• Confusing return types

5. Given a linked list with nodes containing values 5 -> 8 -> 12 -> 20 -> NULL, write a function to search for a value and return the position (1-based) if found, or -1 if not found. What will be the output when searching for 12?

hard

A. -1

B. 3

C. 2

D. 4

Solution

1. Step 1: Understand position counting

   Positions start at 1 for head node, increment by 1 for each next node.

2. Step 2: Locate value 12 in list

   Values: 5 (pos 1), 8 (pos 2), 12 (pos 3), so 12 is at position 3.

3. Final Answer:

   3 -> Option B

4. Quick Check:

   Value 12 is third node [OK]

Hint: Count nodes from head until value found [OK]

Common Mistakes:

• Returning zero-based index instead of 1-based
• Returning -1 even if value exists
• Confusing position with value