Skip to content
geeksforgeeks
  • Courses
    • DSA to Development
    • Get IBM Certification
    • Newly Launched!
      • Master Django Framework
      • Become AWS Certified
    • For Working Professionals
      • Interview 101: DSA & System Design
      • Data Science Training Program
      • JAVA Backend Development (Live)
      • DevOps Engineering (LIVE)
      • Data Structures & Algorithms in Python
    • For Students
      • Placement Preparation Course
      • Data Science (Live)
      • Data Structure & Algorithm-Self Paced (C++/JAVA)
      • Master Competitive Programming (Live)
      • Full Stack Development with React & Node JS (Live)
    • Full Stack Development
    • Data Science Program
    • All Courses
  • Tutorials
    • Data Structures & Algorithms
    • ML & Data Science
    • Interview Corner
    • Programming Languages
    • Web Development
    • CS Subjects
    • DevOps And Linux
    • School Learning
  • Practice
    • Build your AI Agent
    • GfG 160
    • Problem of the Day
    • Practice Coding Problems
    • GfG SDE Sheet
  • Contests
    • Accenture Hackathon (Ending Soon!)
    • GfG Weekly [Rated Contest]
    • Job-A-Thon Hiring Challenge
    • All Contests and Events
  • DSA
  • Interview Problems on Linked List
  • Practice Linked List
  • MCQs on Linked List
  • Linked List Tutorial
  • Types of Linked List
  • Singly Linked List
  • Doubly Linked List
  • Circular Linked List
  • Circular Doubly Linked List
  • Linked List vs Array
  • Time & Space Complexity
  • Advantages & Disadvantages
Open In App
Next Article:
Find Length of a Linked List (Iterative and Recursive)
Next article icon

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)

R

Ravi
Improve
Article Tags :
  • DSA
  • Linked List
  • Python-DSA
Practice Tags :
  • Linked List

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
    3 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
    10 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. Linked List: Linked lists are less rigid in their storage structure and elements are usually not stored in co
    2 min read

    • Types of Linked List

    • Types of Linked List
      A linked list is a linear data structure, in which the elements are not stored at contiguous memory locations. The elements in a linked list are linked using pointers. In simple words, a linked list consists of nodes where each node contains a data field and a reference(link) to the next node in the
      15+ min read
    • Singly Linked List Tutorial
      A singly linked list is a fundamental data structure, it consists of nodes where each node contains a data field and a reference to the next node in the linked list. The next of the last node is null, indicating the end of the list. Linked Lists support efficient insertion and deletion operations. U
      8 min read
    • Doubly Linked List Tutorial
      A doubly linked list is a more complex data structure than a singly linked list, but it offers several advantages. The main advantage of a doubly linked list is that it allows for efficient traversal of the list in both directions. This is because each node in the list contains a pointer to the prev
      9 min read
    • Introduction to Circular Linked List
      A circular linked list is a data structure where the last node connects back to the first, forming a loop. This structure allows for continuous traversal without any interruptions. Circular linked lists are especially helpful for tasks like scheduling and managing playlists, allowing for smooth navi
      15+ min read

    Basic Operations on Linked List

    • Insertion in Linked List
      Insertion 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 lin
      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: NoExplanat
      13 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:
      11 min read
    • Reverse a Linked List
      Given 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 -> NULLOu
      15+ min read
    • Deletion in Linked List
      Deleting 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 Linke
      3 min read
    • Delete a Linked List node at a given position
      Given 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-
      8 min read
    • Write a function to delete a Linked List
      Given 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 o
      9 min read
    • Write a function to get Nth node in a Linked List
      Given 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->
      11 min read
    • Program for Nth node from the end of a Linked List
      Given 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 -
      15 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
geeksforgeeks-footer-logo
Corporate & Communications Address:
A-143, 7th Floor, Sovereign Corporate Tower, Sector- 136, Noida, Uttar Pradesh (201305)
Registered Address:
K 061, Tower K, Gulshan Vivante Apartment, Sector 137, Noida, Gautam Buddh Nagar, Uttar Pradesh, 201305
GFG App on Play Store GFG App on App Store
Advertise with us
  • Company
  • About Us
  • Legal
  • Privacy Policy
  • In Media
  • Contact Us
  • Advertise with us
  • GFG Corporate Solution
  • Placement Training Program
  • Languages
  • Python
  • Java
  • C++
  • PHP
  • GoLang
  • SQL
  • R Language
  • Android Tutorial
  • Tutorials Archive
  • DSA
  • Data Structures
  • Algorithms
  • DSA for Beginners
  • Basic DSA Problems
  • DSA Roadmap
  • Top 100 DSA Interview Problems
  • DSA Roadmap by Sandeep Jain
  • All Cheat Sheets
  • Data Science & ML
  • Data Science With Python
  • Data Science For Beginner
  • Machine Learning
  • ML Maths
  • Data Visualisation
  • Pandas
  • NumPy
  • NLP
  • Deep Learning
  • Web Technologies
  • HTML
  • CSS
  • JavaScript
  • TypeScript
  • ReactJS
  • NextJS
  • Bootstrap
  • Web Design
  • Python Tutorial
  • Python Programming Examples
  • Python Projects
  • Python Tkinter
  • Python Web Scraping
  • OpenCV Tutorial
  • Python Interview Question
  • Django
  • Computer Science
  • Operating Systems
  • Computer Network
  • Database Management System
  • Software Engineering
  • Digital Logic Design
  • Engineering Maths
  • Software Development
  • Software Testing
  • DevOps
  • Git
  • Linux
  • AWS
  • Docker
  • Kubernetes
  • Azure
  • GCP
  • DevOps Roadmap
  • System Design
  • High Level Design
  • Low Level Design
  • UML Diagrams
  • Interview Guide
  • Design Patterns
  • OOAD
  • System Design Bootcamp
  • Interview Questions
  • Inteview Preparation
  • Competitive Programming
  • Top DS or Algo for CP
  • Company-Wise Recruitment Process
  • Company-Wise Preparation
  • Aptitude Preparation
  • Puzzles
  • School Subjects
  • Mathematics
  • Physics
  • Chemistry
  • Biology
  • Social Science
  • English Grammar
  • Commerce
  • World GK
  • GeeksforGeeks Videos
  • DSA
  • Python
  • Java
  • C++
  • Web Development
  • Data Science
  • CS Subjects
@GeeksforGeeks, Sanchhaya Education Private Limited, All rights reserved
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
Improvement
Suggest Changes
Help us improve. Share your suggestions to enhance the article. Contribute your expertise and make a difference in the GeeksforGeeks portal.
geeksforgeeks-suggest-icon
Create Improvement
Enhance the article with your expertise. Contribute to the GeeksforGeeks community and help create better learning resources for all.
geeksforgeeks-improvement-icon
Suggest Changes
min 4 words, max Words Limit:1000

Thank You!

Your suggestions are valuable to us.

What kind of Experience do you want to share?

Interview Experiences
Admission Experiences
Career Journeys
Work Experiences
Campus Experiences
Competitive Exam Experiences