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 :

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?