Saturday, September 21, 2024
Google search engine
HomeData Modelling & AIC++ Program For Searching An Element In A Linked List

C++ Program For Searching An Element In A Linked List

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 <bits/stdc++.h>
using namespace std;
 
// Link list node
class Node
{
    public:
    int key;
    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(Node** head_ref, int new_key)
{
    // Allocate node
    Node* new_node = new 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(Node* head, int x)
{
    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
    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)? cout<<"Yes" : cout<<"No";
    return 0;
}
// This is code is contributed by rathbhupendra


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 <bits/stdc++.h>
using namespace std;
 
// 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)? cout << "Yes" : cout << "No";
    return 0;
}
// This code is contributed by SHUBHAMSINGH10


Output:  

Yes

Time Complexity: O(n), where n represents the length of the given linked list.
Auxiliary Space: O(n), due to 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 neveropen!

RELATED ARTICLES

Most Popular

Recent Comments