Search an element in a Linked List (Iterative and Recursive) (original) (raw)

Last Updated : 18 Feb, 2025

Try it on GfG Practice

Given a linked list and a **key, the task is to check if **key is present in the linked list or not.

**Examples:

**Input: 14 -> 21 -> 11 -> 30 -> 10, key = 14
**Output: Yes
**Explanation: 14 is present in the linked list.

**Input: 6 -> 21 -> 17 -> 30 -> 10 -> 8, key = 13
**Output: No
**Explanation: No node in the linked list has value = 13.

**Input: 9 -> 18 -> 27 -> 36 -> 45, key = 27
**Output: Yes
**Explanation: 27 is present in the linked list.

Search an element in a Linked List (Iterative Approach) - O(N) Time and O(1) Space

The idea is to traverse all the nodes of the linked list, starting from the **head. While traversing, if we find a node whose value is equal to **key then print "Yes", otherwise print "No".

**Follow the below steps to solve the problem:

• Initialize a node pointer, **curr = head.
• Do following while current is not NULL
  • If the current value (i.e., **curr->key) is equal to the key being searched return true.
  • Otherwise, move to the next node (**curr = curr->next).
• If the key is not found, return false C++ `

// Iterative C++ program to search // an element in linked list

#include using namespace std;

// A linked list node class Node { public: int data; Node* next;

// Constructor to initialize a new node with data
Node(int new_data)
{
    data = new_data;
    next = nullptr;
}

};

// Checks whether key is present in linked list bool searchKey(Node* head, int key) {

// Initialize curr with the head of linked list
Node* curr = head;

// Iterate over all the nodes
while (curr != NULL) {

    // If the current node's value is equal to key,
    // return true
    if (curr->data == key)
        return true;

    // Move to the next node
    curr = curr->next;
}

// If there is no node with value as key, return false
return false;

}

// Driver code int main() {

// Create a hard-coded linked list:
// 14 -> 21 -> 13 -> 30 -> 10
Node* head = new Node(14);
head->next = new Node(21);
head->next->next = new Node(13);
head->next->next->next = new Node(30);
head->next->next->next->next = new Node(10);

  // Key to search in the linked list
  int key = 14;

if (searchKey(head, key))
    cout << "Yes";
else
    cout << "No";

return 0;

}

C

// Iterative C program to search // an element in linked list

#include <stdio.h> #include <stdbool.h>

// A linked list node struct Node { int data; struct Node* next; };

// Function to create a new node struct Node* createNode(int new_data) { struct Node* new_node = (struct Node*)malloc(sizeof(struct Node)); new_node->data = new_data; new_node->next = NULL; return new_node; }

// Checks whether key is present in linked list bool searchKey(struct Node* head, int key) {

// Initialize curr with the head of linked list
struct Node* curr = head;

// Iterate over all the nodes
while (curr != NULL) {

    // If the current node's value is equal to key,
    // return true
    if (curr->data == key)
        return true;

    // Move to the next node
    curr = curr->next;
}

// If there is no node with value as key, return false
return false;

}

// Driver code int main() {

// Create a hard-coded linked list:
// 14 -> 21 -> 13 -> 30 -> 10
struct Node* head = createNode(14);
head->next = createNode(21);
head->next->next = createNode(13);
head->next->next->next = createNode(30);
head->next->next->next->next = createNode(10);

  // Key to search in the linked list
  int key = 14;

if (searchKey(head, key))
    printf("Yes");
else
    printf("No");

return 0;

}

Java

// Iterative Java program to search // an element in linked list

// A Linked List Node class Node { int data; Node next;

// Constructor to initialize a new node with data
Node(int new_data) {
    data = new_data;
    next = null;
}

}

public class GFG {

// Checks whether key is present in linked list
static boolean searchKey(Node head, int key) {

    // Initialize curr with the head of linked list
    Node curr = head;

    // Iterate over all the nodes
    while (curr != null) {

        // If the current node's value is equal to key,
        // return true
        if (curr.data == key)
            return true;

        // Move to the next node
        curr = curr.next;
    }

    // If there is no node with value as key, return
    // false
    return false;
}

  // Driver code
public static void main(String[] args) {

    // Create a hard-coded linked list:
    // 14 -> 21 -> 13 -> 30 -> 10
    Node head = new Node(14);
    head.next = new Node(21);
    head.next.next = new Node(13);
    head.next.next.next = new Node(30);
    head.next.next.next.next = new Node(10);

    // Key to search in the linked list
    int key = 14;

    if (searchKey(head, key))
        System.out.println("Yes");
    else
        System.out.println("No");
}

}

Python

Iterative Python program to search

an element in linked list

A Linked List Node

class Node:

  # Constructor to intialize a node with data
def __init__(self, new_data):
    self.data = new_data
    self.next = None

Checks whether key is present in linked list

def search_key(head, key):

# Initialize curr with the head of linked list
curr = head

# Iterate over all the nodes
while curr is not None:

    # If the current node's value is equal to key,
    # return true
    if curr.data == key:
        return True

    # Move to the next node
    curr = curr.next

# If there is no node with value as key, return false
return False

Driver code

if name == "main":

# Create a hard-coded linked list:
# 14 -> 21 -> 13 -> 30 -> 10
head = Node(14)
head.next = Node(21)
head.next.next = Node(13)
head.next.next.next = Node(30)
head.next.next.next.next = Node(10)

# Key to search in the linked list
key = 14

if search_key(head, key):
    print("Yes")
else:
    print("No")

C#

// Iterative C# program to search // an element in linked list

using System;

// A Linked List Node class Node { public int Data; public Node Next;

// Constructor to initialize a new node with data
public Node(int new_data) {
    Data = new_data;
    Next = null;
}

}

// Driver code class GFG {

// Checks whether key is present in linked list
static bool SearchKey(Node head, int key) {

    // Initialize curr with the head of linked list
    Node curr = head;

    // Iterate over all the nodes
    while (curr != null) {

        // If the current node's value is equal to key,
        // return true
        if (curr.Data == key)
            return true;

        // Move to the next node
        curr = curr.Next;
    }

    // If there is no node with value as key, return
    // false
    return false;
}

static void Main() {

    // Create a hard-coded linked list:
    // 14 -> 21 -> 13 -> 30 -> 10
    Node head = new Node(14);
    head.Next = new Node(21);
    head.Next.Next = new Node(13);
    head.Next.Next.Next = new Node(30);
    head.Next.Next.Next.Next = new Node(10);

    // Key to search in the linked list
    int key = 14;

    if (SearchKey(head, key))
        Console.WriteLine("Yes");
    else
        Console.WriteLine("No");
}

}

JavaScript

// Iterative JavaScript program to search // an element in linked list

// A Linked List Node class Node {

// Constructor to initialize a new node with data
constructor(new_data) {
    this.data = new_data;
    this.next = null;
}

}

// Checks whether key is present in linked list function searchKey(head, key) {

// Initialize curr with the head of linked list
let curr = head;

// Iterate over all the nodes
while (curr !== null) {

    // If the current node's value is equal to key,
    // return true
    if (curr.data === key)
        return true;

    // Move to the next node
    curr = curr.next;
}

// If there is no node with value as key, return false
return false;

}

// Driver code

// Create a hard-coded linked list: // 14 -> 21 -> 13 -> 30 -> 10 let head = new Node(14); head.next = new Node(21); head.next.next = new Node(13); head.next.next.next = new Node(30); head.next.next.next.next = new Node(10);

// Key to search in the linked list let key = 14;

if (searchKey(head, key)) console.log("Yes"); else console.log("No");

`

Search an element in a Linked List (Recursive Approach) - O(N) Time and O(N) Space

The idea is to recursively traverse all the nodes starting from the **head of linked list. For any node, if the value is equal to **key, then return true. Otherwise, recursively search the next node. If at any point the head reaches **NULL, it means that we have reached the end of linked list so return **false.

**Follow the below steps to solve the problem:

• If the head is NULL, return false.
• If the head's key is the same as **X, return true;
• Else recursively search in the next node. C++ `

// Recursive C++ program to search // an element in linked list

#include using namespace std;

// A Linked List Node struct Node { int data; Node* next;

  // Constructor to initialize a new node with data
Node(int new_data) {
    data = new_data;
    next = nullptr;
}

};

// Checks whether the key is present in linked list bool searchKey(struct Node* head, int key) {

// Base case
if (head == NULL)
    return false;

// If key is present in current node, return true
if (head->data == key)
    return true;

// Recur for remaining list
return searchKey(head->next, key);

}

// Driver code int main() {

// Create a hard-coded linked list:
// 14 -> 21 -> 13 -> 30 -> 10
struct Node* head = new Node(14);
head->next = new Node(21);
head->next->next = new Node(13);
head->next->next->next = new Node(30);
head->next->next->next->next = new Node(10);

  // Key to search in the linked list
  int key = 14;

if (searchKey(head, key))
    printf("Yes");
else
    printf("No");

return 0;

}

C

// Recursive C program to search // an element in linked list

#include <stdio.h> #include <stdbool.h>

// A linked list node struct Node { int data; struct Node* next; };

// Function to create a new node struct Node* createNode(int new_data) { struct Node* new_node = (struct Node*)malloc(sizeof(struct Node)); new_node->data = new_data; new_node->next = NULL; return new_node; }

// Checks whether the key is present in linked list bool searchKey(struct Node* head, int key) {

// Base case
if (head == NULL)
    return 0;

// If key is present in current node, return true
if (head->data == key)
    return 1;

// Recur for remaining list
return searchKey(head->next, key);

}

// Driver code int main() {

// Create a hard-coded linked list:
// 14 -> 21 -> 13 -> 30 -> 10
struct Node* head = createNode(14);
head->next = createNode(21);
head->next->next = createNode(13);
head->next->next->next = createNode(30);
head->next->next->next->next = createNode(10);

  // Key to search in the linked list
  int key = 14;

if (searchKey(head, key))
    printf("Yes");
else
    printf("No");

return 0;

}

Java

// Recursive Java program to search // an element in linked list

// A Linked List Node class Node { int data; Node next;

// Constructor to initialize a new node with data
Node(int new_data) {
    data = new_data;
    next = null;
}

}

// Driver code public class GFG {

// Checks whether the key is present in linked list
static boolean searchKey(Node head, int key) {

    // Base case
    if (head == null)
        return false;

    // If key is present in current node, return true
    if (head.data == key)
        return true;

    // Recur for remaining list
    return searchKey(head.next, key);
}

public static void main(String[] args) {

    // Create a hard-coded linked list:
    // 14 -> 21 -> 13 -> 30 -> 10
    Node head = new Node(14);
    head.next = new Node(21);
    head.next.next = new Node(13);
    head.next.next.next = new Node(30);
    head.next.next.next.next = new Node(10);

    // Key to search in the linked list
    int key = 14;

    if (searchKey(head, key))
        System.out.println("Yes");
    else
        System.out.println("No");
}

}

Python

Recursive Python program to search

an element in linked list

A Linked List Node

class Node:

  # Constructor to initialize a new node with data
def __init__(self, new_data):
    self.data = new_data
    self.next = None

Checks whether the key is present in linked list

def searchKey(head, key):

# Base case
if head is None:
    return False

# If key is present in current node, return true
if head.data == key:
    return True

# Recur for remaining list
return searchKey(head.next, key)

Driver code

if name == "main":

# Create a hard-coded linked list:
# 14 -> 21 -> 13 -> 30 -> 10
head = Node(14)
head.next = Node(21)
head.next.next = Node(13)
head.next.next.next = Node(30)
head.next.next.next.next = Node(10)

# Key to search in the linked list
key = 14

if searchKey(head, key):
    print("Yes")
else:
    print("No")

C#

// Recursive C# program to search // an element in linked list

using System;

// A Linked List Node class Node { public int data; public Node next;

// Constructor to initialize a new node with data
public Node(int new_data) {
    data = new_data;
    next = null;
}

}

// Checks whether the key is present in linked list class GFG {

  // Checks whether the key is present in linked list
static bool SearchKey(Node head, int key) {
  
    // Base case
    if (head == null)
        return false;

    // If key is present in current node, return true
    if (head.data == key)
        return true;

    // Recur for remaining list
    return SearchKey(head.next, key);
}

static void Main() {
  
    // Create a hard-coded linked list:
    // 14 -> 21 -> 13 -> 30 -> 10
    Node head = new Node(14);
    head.next = new Node(21);
    head.next.next = new Node(13);
    head.next.next.next = new Node(30);
    head.next.next.next.next = new Node(10);

    // Key to search in the linked list
    int key = 14;

    if (SearchKey(head, key))
        Console.WriteLine("Yes");
    else
        Console.WriteLine("No");
}

}

JavaScript

// Recursive Javascript program to search // an element in linked list

// A Linked List Node class Node {

// Constructor to initialize a new node with data
constructor(new_data) {
    this.data = new_data;
    this.next = null;
}

}

// Checks whether the key is present in linked list function searchKey(head, key) {

// Base case
if (head === null) 
    return false;

// If key is present in current node, return true
if (head.data === key) 
    return true;

// Recur for remaining list
return searchKey(head.next, key);

}

// Create a hard-coded linked list: // 14 -> 21 -> 13 -> 30 -> 10 let head = new Node(14); head.next = new Node(21); head.next.next = new Node(13); head.next.next.next = new Node(30); head.next.next.next.next = new Node(10);

// Key to search in the linked list let key = 14;

if (searchKey(head, key)) console.log("Yes"); else console.log("No");

`