Open In App
Related Articles

C Program For Searching An Element In A Linked List

Improve Article
Improve
Save Article
Save
Like Article
Like

Write a function that searches a given key ‘x’ in a given singly linked list. The function should return true if x is present in linked list and false otherwise.

bool search(Node *head, int x)

For example, if the key to be searched is 15 and linked list is 14->21->11->30->10, then function should return false. If key to be searched is 14, then the function should return true.
Iterative Solution: 

1) Initialize a node pointer, current = head.
2) Do following while current is not NULL
    a) current->key is equal to the key being searched return true.
    b) current = current->next
3) Return false 

Following is iterative implementation of above algorithm to search a given key.

C




// Iterative C program to search an
// element in linked list
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
 
// Link list node
struct Node
{
    int key;
    struct Node* next;
};
 
/* Given a reference (pointer to pointer) to
   the head of a list and an int, push a new
   node on the front of the list. */
void push(struct Node** head_ref,
          int new_key)
{
    // Allocate node
    struct Node* new_node =
           (struct Node*) malloc(sizeof(struct Node));
 
    // Put in the key
    new_node->key = new_key;
 
    // Link the old list of the new node
    new_node->next = (*head_ref);
 
    // Move the head to point to the new node
    (*head_ref) = new_node;
}
 
// Checks whether the value x is present
// in linked list
bool search(struct Node* head, int x)
{
    // Initialize current
    struct Node* current = head; 
    while (current != NULL)
    {
        if (current->key == x)
            return true;
        current = current->next;
    }
    return false;
}
 
// Driver code
int main()
{
    // Start with the empty list
    struct Node* head = NULL;
    int x = 21;
 
    // Use push() to construct list
    // 14->21->11->30->10
    push(&head, 10);
    push(&head, 30);
    push(&head, 11);
    push(&head, 21);
    push(&head, 14);
 
    search(head, 21)? printf("Yes") : printf("No");
    return 0;
}


Output: 

Yes

Time Complexity: O(n), where n represents the length of the given linked list.
Auxiliary Space: O(1), no extra space is required, so it is a constant.

Recursive Solution:

bool search(head, x)
1) If head is NULL, return false.
2) If head's key is same as x, return true;
3) Else return search(head->next, x) 

Following is the recursive implementation of the above algorithm to search a given key.

C




// Recursive C program to search an
// element in linked list
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
// Link list node
struct Node
{
    int key;
    struct Node* next;
};
 
/* Given a reference (pointer to pointer) to
   the head of a list and an int, push a new
   node on the front of the list. */
void push(struct Node** head_ref,
          int new_key)
{
    // Allocate node
    struct Node* new_node =
           (struct Node*) malloc(sizeof(struct Node));
 
    // Put in the key
    new_node->key = new_key;
 
    // Link the old list of the new node
    new_node->next = (*head_ref);
 
    // Move the head to point to the new node
    (*head_ref) = new_node;
}
 
// Checks whether the value x is present
// in linked list
bool search(struct Node* head, int x)
{
    // Base case
    if (head == NULL)
        return false;
     
    // If key is present in current
    // node, return true
    if (head->key == x)
        return true;
 
    // Recur for remaining list
    return search(head->next, x);
}
 
// Driver code
int main()
{
    // Start with the empty list
    struct Node* head = NULL;
    int x = 21;
 
    // Use push() to construct list
    // 14->21->11->30->10
    push(&head, 10);
    push(&head, 30);
    push(&head, 11);
    push(&head, 21);
    push(&head, 14);
 
    search(head, 21)? printf("Yes") : printf("No");
    return 0;
}


Output:

Yes

Time Complexity: O(n), where n represents the length of the given linked list.
Auxiliary Space: O(n), for recursive call stack where n represents the length of the given linked list.

Please refer complete article on Search an element in a Linked List (Iterative and Recursive) for more details!


Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!

Last Updated : 16 Feb, 2023
Like Article
Save Article
Previous
Next
Similar Reads
Complete Tutorials