Search an element in a Linked List (Iterative and Recursive)
Last Updated :
18 Feb, 2025
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;
}
// 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;
}
// 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");
}
}
# 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")
// 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");
}
}
// 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 <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;
}
// 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;
}
// 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");
}
}
# 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")
// 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");
}
}
// 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");
Similar Reads
Linked List Data Structure A linked list is a fundamental data structure in computer science. It mainly allows efficient insertion and deletion operations compared to arrays. Like arrays, it is also used to implement other data structures like stack, queue and deque. Here’s the comparison of Linked List vs Arrays Linked List:
3 min read
Basic Terminologies of Linked List Linked List is a linear data structure, in which elements are not stored at a contiguous location, rather they are linked using pointers. Linked List forms a series of connected nodes, where each node stores the data and the address of the next node.Node Structure: A node in a linked list typically
2 min read
Introduction to Linked List - Data Structure and Algorithm Tutorials Linked List is basically chains of nodes where each node contains information such as data and a pointer to the next node in the chain. It is a popular data structure with a wide range of real-world applications. Unlike Arrays, Linked List elements are not stored at a contiguous location. In the lin
9 min read
Applications, Advantages and Disadvantages of Linked List A Linked List is a linear data structure that is used to store a collection of data with the help of nodes. Please remember the following points before moving forward.The consecutive elements are connected by pointers / references.The last node of the linked list points to null.The entry point of a
4 min read
Linked List vs Array Array: Arrays store elements in contiguous memory locations, resulting in easily calculable addresses for the elements stored and this allows faster access to an element at a specific index.Data storage scheme of an arrayLinked List: Linked lists are less rigid in their storage structure and element
2 min read
Types of Linked List
Basic Operations on Linked List
Insertion in Linked ListInsertion in a linked list involves adding a new node at a specified position in the list. There are several types of insertion based on the position where the new node is to be added:At the front of the linked list Before a given node.After a given node.At a specific position.At the end of the link
4 min read
Search an element in a Linked List (Iterative and Recursive)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 = 14Output: YesExplanation: 14 is present in the linked list.Input: 6 -> 21 -> 17 -> 30 -> 10 -> 8, key = 13Output: NoExplanatio
12 min read
Find Length of a Linked List (Iterative and Recursive)Given a Singly Linked List, the task is to find the Length of the Linked List.Examples:Input: LinkedList = 1->3->1->2->1Output: 5Explanation: The linked list has 5 nodes.Input: LinkedList = 2->4->1->9->5->3->6Output: 7 Explanation: The linked list has 7 nodes.Input: Lin
11 min read
Reverse a Linked ListGiven a linked list, the task is to reverse the linked list by changing the links between nodes.Examples: Input: head: 1 -> 2 -> 3 -> 4 -> NULLOutput: head: 4 -> 3 -> 2 -> 1 -> NULLExplanation: Reversed Linked List: Input: head: 1 -> 2 -> 3 -> 4 -> 5 -> NULLOut
15+ min read
Deletion in Linked ListDeleting a node in a Linked List is an important operation and can be done in three main ways: removing the first node, removing a node in the middle, or removing the last node.In this article, we will explore deletion operation on Linked List for all the above scenarios. Types of Deletion in Linked
3 min read
Delete a Linked List node at a given positionGiven a singly linked list and a position (1-based indexing), the task is to delete a linked list node at the given position.Note: Position will be valid (i.e, 1 <= position <= linked list length)Example: Input: position = 2, Linked List = 8->2->3->1->7Output: Linked List = 8->3
8 min read
Write a function to delete a Linked ListGiven a linked list, the task is to delete the linked list completely.Examples:Input: head: 1 -> 2 -> 3 -> 4 -> 5 -> NULLOutput: NULLExplanation: Linked List is Deleted.Input: head: 1 -> 12 -> 1 -> 4 -> 1 -> NULLOutput: NULLExplanation: Linked List is Deleted.Table of C
9 min read
Write a function to get Nth node in a Linked ListGiven a LinkedList and an index (1-based). The task is to find the data value stored in the node at that kth position. If no such node exists whose index is k then return -1.Example:Â Input: 1->10->30->14, index = 2Output: 10Explanation: The node value at index 2 is 10 Input: 1->32->12
11 min read
Program for Nth node from the end of a Linked ListGiven a Linked List of M nodes and a number N, find the value at the Nth node from the end of the Linked List. If there is no Nth node from the end, print -1.Examples:Input: 1 -> 2 -> 3 -> 4, N = 3Output: 2Explanation: Node 2 is the third node from the end of the linked list.Input: 35 ->
14 min read
Top 50 Problems on Linked List Data Structure asked in SDE Interviews A Linked List is a linear data structure that looks like a chain of nodes, where each node is a different element. Unlike Arrays, Linked List elements are not stored at a contiguous location. Here is the collection of the Top 50 list of frequently asked interview questions on Linked Lists. Problems
3 min read