Open In App

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

Last Updated : 18 Feb, 2025
Comments
Improve
Suggest changes
Like Article
Like
Report
Try it on GfG Practice
redirect icon

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 <iostream>
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");

Output
Yes

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 <iostream>
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");

Output
Yes



Next Article
Find Length of a Linked List (Iterative and Recursive)

K

kartik
Improve
Article Tags :
Practice Tags :

Similar Reads

We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy
Lightbox