Search an element in a Doubly Linked List

Last Updated : 04 Sep, 2024

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: Linked List = 18 <-> 15 <-> 8 <-> 9 <-> 14, x = 8
Output: 3

Explanation: x= 8 is present at the 3rd node of the doubly linked list.
Input: LinkedList = 5 <-> 3 <-> 4 <-> 2 <-> 9, x= 0
Output: -1
Explanation: x = 0 is not present in the doubly linked list.

Approach:

The idea is to Iterate through the doubly linked list while tracking the position to find the node with value x. If found return the position , otherwise return -1.

Follow the steps below to solve the problem:

Initialize a variable pos to store the position of the node containing data value x in the doubly linked list.
Initialize a pointer curr 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 return pos.
return -1 as the node with value x is not present.

Below is the implementation of the above approach :

C++

//C++ Code for Searching in
//Doubly Linked List
#include <iostream>
using namespace std;

class Node {
public:
    int data;
    Node* next;
    Node* prev;

    Node(int new_data) {
        data = new_data;
        next = nullptr;
        prev = nullptr;
    }
};

// Function to find the position of an integer
// in a doubly linked list
int search(Node* head, int x) {
    Node* curr = head;
    int pos = 0;

    // Traverse the doubly linked list
    while (curr != nullptr && curr->data != x) {
        pos++;
        curr = curr->next;
    }

    // If the integer is not present
    if (curr == nullptr || curr->data != x)
        return -1;

    // If the integer is present
    return (pos + 1);
}

int main() {
    Node* head = nullptr;
    int x = 8;

    // Create a hard-coded linked list:
    // 18 <=> 15 <=> 8 <=> 9 <=> 14
    head = new Node(18);
    head->next = new Node(15);
    head->next->prev = head;
    head->next->next = new Node(8);
    head->next->next->prev = head->next;
    head->next->next->next = new Node(9);
    head->next->next->next->prev = head->next->next;
    head->next->next->next->next = new Node(14);
    head->next->next->next->next->prev = 
        head->next->next->next;

    cout << search(head, x);

    return 0;
}

// C Code for Searching in Doubly Linked List
#include <stdio.h>
#include <stdlib.h>

struct Node {
    int data;
    struct Node* next;
    struct Node* prev;
};

// Function to find the position of an integer
// in the doubly linked list
int search(struct Node* head, int x) {
    struct Node* curr = head;
    int pos = 0;

    // Traverse the doubly linked list
    while (curr != NULL && curr->data != x) {
        pos++;
        curr = curr->next;
    }

    // If the integer is not present in the list
    if (curr == NULL || curr->data != x)
        return -1;

    // If the integer is present in the list
    return (pos + 1);
}

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;
    new_node->prev = NULL;
    return new_node;
}

int main() {
    struct Node* head = NULL;
    int x = 8;

    // Create a hard-coded doubly linked list:
    // 18 <=> 15 <=> 8 <=> 9 <=> 14
    head = createNode(18);
    head->next = createNode(15);
    head->next->prev = head;
    head->next->next = createNode(8);
    head->next->next->prev = head->next;
    head->next->next->next = createNode(9);
    head->next->next->next->prev = head->next->next;
    head->next->next->next->next = createNode(14);
    head->next->next->next->next->prev =
        head->next->next->next;

    printf("%d\n", search(head, x));

    return 0;
}

Java

// Java Code for Searching in
// Doubly Linked List
class Node {
    int data;
    Node next;
    Node prev;

    Node(int new_data) {
        data = new_data;
        next = null;
        prev = null;
    }
}

public class GfG {

    // Function to find the position of an integer
    static int search(Node head, int x) {
        Node curr = head;
        int pos = 0;

        // Traverse the doubly linked list
        while (curr != null && curr.data != x) {
            pos++;
            curr = curr.next;
        }

        // If the integer is not present in the list
        if (curr == null || curr.data != x)
            return -1;

        // If the integer is present in the list
        return (pos + 1);
    }

    public static void main(String[] args) {
        Node head = null;
        int x = 8;

        // Create a hard-coded linked list:
        // 18 <=> 15 <=> 8 <=> 9 <=> 14
        head = new Node(18);
        head.next = new Node(15);
        head.next.prev = head;
        head.next.next = new Node(8);
        head.next.next.prev = head.next;
        head.next.next.next = new Node(9);
        head.next.next.next.prev = head.next.next;
        head.next.next.next.next = new Node(14);
        head.next.next.next.next.prev = 
            head.next.next.next;

        System.out.print(search(head, x));
    }
}

Python

# Python Code for Searching in Doubly Linked List

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None
        self.prev = None

# Function to find the position of an integer
# in the doubly linked list
def search(head, x):
    curr = head
    pos = 0

    # Traverse the doubly linked list
    while curr is not None and curr.data != x:
        pos += 1
        curr = curr.next

    # If the integer is not present
    if curr is None or curr.data != x:
        return -1
    
    # If the integer is present in the list
    return pos + 1

if __name__ == '__main__':
    head = None
    x = 8

    # Create a hard-coded linked list:
    # 18 <=> 15 <=> 8 <=> 9 <=> 14
    head = Node(18)
    head.next = Node(15)
    head.next.prev = head
    head.next.next = Node(8)
    head.next.next.prev = head.next
    head.next.next.next = Node(9)
    head.next.next.next.prev = head.next.next
    head.next.next.next.next = Node(14)
    head.next.next.next.next.prev = head.next.next.next

    print(search(head, x))

//C# Code for Searching in
//Doubly Linked List
using System;

class Node {
    public int Data;
    public Node next;
    public Node prev;

    public Node(int data) {
        Data = data;
        next = null;
        prev = null;
    }
}

class GfG {
  
    // Function to find the position of an integer
    static int Search(Node head, int x) {
        Node curr = head;
        int pos = 0;

        while (curr != null && curr.Data != x) {
            pos++;
            curr = curr.next;
        }

        // If the integer is not present in the list
        if (curr == null || curr.Data != x)
            return -1;

        // If the integer is present in the list
        return pos + 1;
    }

    static void Main() {
        Node head = null;
        int x = 8;

        // Create a hard-coded linked list:
        // 18 <=> 15 <=> 8 <=> 9 <=> 14
        head = new Node(18);
        head.next = new Node(15);
        head.next.prev = head;
        head.next.next = new Node(8);
        head.next.next.prev = head.next;
        head.next.next.next = new Node(9);
        head.next.next.next.prev = head.next.next;
        head.next.next.next.next = new Node(14);
        head.next.next.next.next.prev = head.next.next.next;

        Console.WriteLine(Search(head, x));
    }
}

JavaScript

// JavaScript Code for Searching
// in Doubly Linked List
class Node {
    constructor(data) {
        this.data = data;
        this.next = null;
        this.prev = null;
    }
}

// Function to find the position of an integer
function search(head, x) {
    let curr = head;
    let pos = 0;

    while (curr !== null && curr.data !== x) {
        pos++;
        curr = curr.next;
    }

    // If the integer is not present in the list
    if (curr === null) {
        return -1;
    }

    // If the integer is present in the list
    return pos + 1;
}

let head = null;
const x = 8;

// Create a hard-coded doubly linked list:
// 18 <=> 15 <=> 8 <=> 9 <=> 14
head = new Node(14);
head.prev = null;
head.next = new Node(9);
head.next.prev = head;
head.next.next = new Node(8);
head.next.next.prev = head.next;
head.next.next.next = new Node(15);
head.next.next.next.prev = head.next.next;
head.next.next.next.next = new Node(18);
head.next.next.next.next.prev = head.next.next.next;

console.log(search(head, x));

Output

Time Complexity: O(n), where n is the number of nodes in the list.
Auxiliary Space: O(1).

Deletion in a Doubly Linked List

pradiptamukherjee

Improve

Article Tags :

Practice Tags :

Doubly Linked List in Different Languages

How to Create a Doubly Linked List in C?

A doubly linked list is a type of linked list in which each node contains a pointer to both the next node and the previous node. This allows traversal in both forward and backward directions. Each node in a doubly linked list stores data, a pointer to the next node, and a pointer to the previous nod

4 min read

Introduction to Doubly Linked Lists in Java

Doubly linked list is a data structure that has reference to both the previous and next nodes in the list. It provides simplicity to traverse, insert and delete the nodes in both directions in a list. In a doubly linked list, each node contains three data members: data: The data stored in the nodene

11 min read

Implementation of Doubly Linked List in JavaScript

This article will demonstrate the Implementation of Doubly Linked List In JavaScript. A doubly linked list (DLL) is a special type of linked list in which each node contains a pointer to the previous node as well as the next node of the linked list. Doubly Linked List in JavaScriptTo create we have

4 min read

Memory efficient doubly linked list

We need to implement a doubly linked list with the use of a single pointer in each node. For that we are given a stream of data of size n for the linked list, your task is to make the function insert() and getList(). The insert() function pushes (or inserts at the beginning) the given data in the li

9 min read

Search an element in a Doubly Linked List

Similar Reads

Operations on Doubly Linked

Doubly Linked List in Different Languages

Thank You!

What kind of Experience do you want to share?