Search an element in a Doubly Linked List

28 Mar, 2022
Given a Doubly linked list(DLL) containing N nodes and an integer X, the task is to find the position of the integer X in the doubly linked list. If no such position found then print -1.
Examples:
Input: 15 <=> 16 <=> 8 <=> 7 <=> 13, X = 8 Output: 3 Explanation: X (= 8) is present at the 3rd node of the doubly linked list. Therefore, the required output is 3
Input: 5 <=> 3 <=> 4 <=> 2 <=> 9, X = 0 Output: -1 Explanation: X (= 0) is not present in the doubly linked list. Therefore, the required output is -1
Approach: Follow the steps below to solve the problem:
Initialize a variable, say pos, to store the position of the node containing data value X in the doubly linked list.
Initialize a pointer, say temp, to store the head node of the doubly linked list.
Iterate over the linked list and for every node, check if data value of that node is equal to X or not. If found to be true, then print pos.
Otherwise, print -1.
Below is the implementation of the above approach
C++
Java
C#
Javascript
Python3
// C++ program to implement// the above approach #include <bits/stdc++.h>using namespace std; // Structure of a node of// the doubly linked liststruct Node {     // Stores data value    // of a node    int data;     // Stores pointer    // to next node    Node* next;     // Stores pointer    // to previous node    Node* prev;}; // Function to insert a node at the// beginning of the Doubly Linked Listvoid push(Node** head_ref, int new_data){     // Allocate memory for new node    Node* new_node        = (Node*)malloc(sizeof(struct Node));     // Insert the data    new_node->data = new_data;     // Since node is added at the    // beginning, prev is always NULL    new_node->prev = NULL;     // Link the old list to the new node    new_node->next = (*head_ref);     // If pointer to head is not NULL    if ((*head_ref) != NULL) {         // Change the prev of head        // node to new node        (*head_ref)->prev = new_node;    }     // Move the head to point to the new node    (*head_ref) = new_node;} // Function to find the position of// an integer in doubly linked listint search(Node** head_ref, int x){     // Stores head Node    Node* temp = *head_ref;     // Stores position of the integer    // in the doubly linked list    int pos = 0;     // Traverse the doubly linked list    while (temp->data != x           && temp->next != NULL) {         // Update pos        pos++;         // Update temp        temp = temp->next;    }     // If the integer not present    // in the doubly linked list    if (temp->data != x)        return -1;     // If the integer present in    // the doubly linked list    return (pos + 1);} // Driver Codeint main(){    Node* head = NULL;    int X = 8;     // Create the doubly linked list    // 18 <-> 15 <-> 8 <-> 9 <-> 14    push(&head, 14);    push(&head, 9);    push(&head, 8);    push(&head, 15);    push(&head, 18);     cout << search(&head, X);     return 0;}
// Java program to implement// the above approachimport java.util.*;class GFG{     // Structure of a node of  // the doubly linked list  static class Node  {    // Stores data value    // of a node    int data;         // Stores pointer    // to next node    Node next;         // Stores pointer    // to previous node    Node prev;  };     // Function to insert a node at the  // beginning of the Doubly Linked List  static Node push(Node head_ref, int new_data)  {         // Allocate memory for new node    Node new_node = new Node();         // Insert the data    new_node.data = new_data;         // Since node is added at the    // beginning, prev is always null    new_node.prev = null;         // Link the old list to the new node    new_node.next = head_ref;         // If pointer to head is not null    if (head_ref != null)    {             // Change the prev of head      // node to new node      head_ref.prev = new_node;    }         // Move the head to point to the new node    head_ref = new_node;    return head_ref;  }     // Function to find the position of  // an integer in doubly linked list  static int search(Node head_ref, int x)  {         // Stores head Node    Node temp = head_ref;         // Stores position of the integer    // in the doubly linked list    int pos = 0;         // Traverse the doubly linked list    while (temp.data != x               && temp.next != null)    {      // Update pos      pos++;             // Update temp      temp = temp.next;    }         // If the integer not present    // in the doubly linked list    if (temp.data != x)      return -1;    // If the integer present in    // the doubly linked list    return (pos + 1);  }     // Driver Code  public static void main(String[] args)  {    Node head = null;    int X = 8;    // Create the doubly linked list    // 18 <-> 15 <-> 8 <-> 9 <-> 14    head = push(head, 14);    head = push(head, 9);    head = push(head, 8);    head = push(head, 15);    head = push(head, 18);    System.out.print(search(head, X));  }} // This code is contributed by Rajput-Ji
// C# program to implement// the above approachusing System; class GFG{   // Structure of a node of// the doubly linked listpublic class Node{         // Stores data value    // of a node    public int data;         // Stores pointer    // to next node    public Node next;         // Stores pointer    // to previous node    public Node prev;}; // Function to insert a node at the// beginning of the Doubly Linked Liststatic Node push(Node head_ref, int new_data){         // Allocate memory for new node    Node new_node = new Node();         // Insert the data    new_node.data = new_data;         // Since node is added at the    // beginning, prev is always null    new_node.prev = null;         // Link the old list to the new node    new_node.next = head_ref;         // If pointer to head is not null    if (head_ref != null)    {                 // Change the prev of head        // node to new node        head_ref.prev = new_node;    }         // Move the head to point to the new node    head_ref = new_node;    return head_ref;} // Function to find the position of// an integer in doubly linked liststatic int search(Node head_ref, int x){         // Stores head Node    Node temp = head_ref;         // Stores position of the integer    // in the doubly linked list    int pos = 0;         // Traverse the doubly linked list    while (temp.data != x &&           temp.next != null)    {                 // Update pos        pos++;                 // Update temp        temp = temp.next;    }         // If the integer not present    // in the doubly linked list    if (temp.data != x)        return -1;             // If the integer present in    // the doubly linked list    return (pos + 1);} // Driver Codepublic static void Main(String[] args){    Node head = null;    int X = 8;         // Create the doubly linked list    // 18 <-> 15 <-> 8 <-> 9 <-> 14    head = push(head, 14);    head = push(head, 9);    head = push(head, 8);    head = push(head, 15);    head = push(head, 18);         Console.Write(search(head, X));}} // This code is contributed by gauravrajput1
<script> // Javascript program to implement// the above approach // Structure of a node of// the doubly linked listclass Node {     constructor()    {         // Stores data value         // of a node         this.data = 0;          // Stores pointer         // to next node         this.next = null;          // Stores pointer         // to previous node         this.prev = null;    }}; // Function to insert a node at the// beginning of the Doubly Linked Listfunction push(head_ref, new_data){     // Allocate memory for new node    var new_node        = new Node();     // Insert the data    new_node.data = new_data;     // Since node is added at the    // beginning, prev is always null    new_node.prev = null;     // Link the old list to the new node    new_node.next = (head_ref);     // If pointer to head is not null    if ((head_ref) != null) {         // Change the prev of head        // node to new node        (head_ref).prev = new_node;    }     // Move the head to point to the new node    (head_ref) = new_node;     return head_ref;} // Function to find the position of// an integer in doubly linked listfunction search( head_ref, x){     // Stores head Node    var temp = head_ref;     // Stores position of the integer    // in the doubly linked list    var pos = 0;     // Traverse the doubly linked list    while (temp.data != x           && temp.next != null) {         // Update pos        pos++;         // Update temp        temp = temp.next;    }     // If the integer not present    // in the doubly linked list    if (temp.data != x)        return -1;     // If the integer present in    // the doubly linked list    return (pos + 1);} // Driver Codevar head = null;var X = 8; // Create the doubly linked list// 18 <. 15 <. 8 <. 9 <. 14head = push(head, 14);head = push(head, 9);head = push(head, 8);head = push(head, 15);head = push(head, 18);document.write( search(head, X)); // This code is contributed by rrrtnx.</script>
# Python program to implement# the above approach # Structure of a Node of# the doubly linked listclass Node:    def __init__(self):        self.data = 0;        self.next = None;        self.prev = None; # Function to insert a Node at the# beginning of the Doubly Linked Listdef push(head_ref, new_data):     # Allocate memory for new Node    new_Node = Node();     # Insert the data    new_Node.data = new_data;     # Since Node is added at the    # beginning, prev is always None    new_Node.prev = None;     # Link the old list to the new Node    new_Node.next = head_ref;     # If pointer to head is not None    if (head_ref != None):         # Change the prev of head        # Node to new Node        head_ref.prev = new_Node;         # Move the head to point to the new Node    head_ref = new_Node;    return head_ref; # Function to find the position of# an integer in doubly linked listdef search(head_ref, x):     # Stores head Node    temp = head_ref;     # Stores position of the integer    # in the doubly linked list    pos = 0;     # Traverse the doubly linked list    while (temp.data != x and temp.next != None):        # Update pos        pos+=1;         # Update temp        temp = temp.next;         # If the integer not present    # in the doubly linked list    if (temp.data != x):        return -1;           # If the integer present in    # the doubly linked list    return (pos + 1); # Driver Codeif __name__ == '__main__':    head = None;    X = 8;         # Create the doubly linked list    # 18 <-> 15 <-> 8 <-> 9 <-> 14    head = push(head, 14);    head = push(head, 9);    head = push(head, 8);    head = push(head, 15);    head = push(head, 18);    print(search(head, X)); # This code is contributed by Rajput-Ji
3
 
Time Complexity: O(N)Auxiliary Space: O(1)
Rajput-Ji
GauravRajput1
rrrtnx
surinderdawra388
Algorithms-Searching
doubly linked list
Technical Scripter 2020
Linked List
Searching
Technical Scripter
Linked List
Searching
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.