Search an Element in Doubly Circular Linked List (original) (raw)

Last Updated : 11 Jul, 2025

Pre-requisite: Convert an Array to a Circular Doubly Linked List, Doubly Circular Linked List
Given a doubly circular linked list. The task is to find the position of an element in the list.

Image Representation:

Search Image

Algorithm:

Declare a temp pointer, and initialize it to the head of the list.
Iterate the loop until temp reaches the start address (last node in the list, as it is in a circular fashion), and check for the n element, whether present or not.
If it is present, raise a flag, increment count, and break the loop.
At the last, as the last node is not visited yet check for the n element if present does step 3.

The below program illustrates the above approach:

C++ `

// C++ program to illustrate inserting a Node in // a Circular Doubly Linked list in begging, end // and middle #include <bits/stdc++.h> using namespace std;

// Structure of a Node struct Node { int data; struct Node *next; struct Node *prev; };

// Function to insert a node at the end void insertNode(struct Node** start, int value) { // If the list is empty, create a single node // circular and doubly list if (start == NULL) { struct Node new_node = new Node; new_node->data = value; new_node->next = new_node->prev = new_node; *start = new_node; return; }

// If list is not empty 

/* Find last node */
Node *last = (*start)->prev; 

// Create Node dynamically 
struct Node* new_node = new Node; 
new_node->data = value; 

// Start is going to be next of new_node 
new_node->next = *start; 

// Make new node previous of start 
(*start)->prev = new_node; 

// Make last previous of new node 
new_node->prev = last; 

// Make new node next of old last 
last->next = new_node;

}

// Function to display the // circular doubly linked list void displayList(struct Node* start) { struct Node *temp = start;

while (temp->next != start) 
{ 
    printf("%d ", temp->data); 
    temp = temp->next; 
} 
printf("%d ", temp->data);

}

// Function to search the particular element // from the list int searchList(struct Node* start, int search) { // Declare the temp variable struct Node *temp = start;

// Declare other control
// variable for the searching
int count=0,flag=0,value;
 
// If start is NULL return -1
if(temp == NULL)
    return -1;
else
{
    // Move the temp pointer until, 
    // temp->next doesn't move
    // start address (Circular Fashion)
    while(temp->next != start)
    {
        // Increment count for location
        count++;
        // If it is found raise the
        // flag and break the loop
        if(temp->data == search)
        {
            flag = 1;
            count--;
            break;
        }
        // Increment temp pointer
        temp = temp->next;   
    }
    // Check whether last element in the
    // list content the value if contain, 
    // raise a flag and increment count
    if(temp->data == search)
    {
        count++;
        flag = 1;
    }
     
    // If flag is true, then element
    // found, else not
    if(flag == 1)
        cout<<"\n"<<search <<" found at location "<<
                                        count<<endl;
    else
        cout<<"\n"<<search <<" not found"<<endl;
}

}

// Driver code int main() { /* Start with the empty list / struct Node start = NULL;

// Insert 4. So linked list becomes 4->NULL 
insertNode(&start, 4);

// Insert 5. So linked list becomes 4->5 
insertNode(&start, 5);  

// Insert 7. So linked list 
// becomes 4->5->7 
insertNode(&start, 7); 

// Insert 8. So linked list 
// becomes 4->5->7->8 
insertNode(&start, 8); 

// Insert 6. So linked list 
// becomes 4->5->7->8->6 
insertNode(&start, 6); 

printf("Created circular doubly linked list is: "); 
displayList(start); 

searchList(start, 5);

return 0;

}

Java

// Java program to illustrate inserting
// a Node in a Circular Doubly Linked list // in begging, end and middle class GFG {

// Structure of a Node static class Node { int data; Node next; Node prev; };

// Function to insert a node at the end static Node insertNode(Node start, int value) { // If the list is empty, create a single node // circular and doubly list if (start == null) { Node new_node = new Node(); new_node.data = value; new_node.next = new_node.prev = new_node; start = new_node; return new_node; }

// If list is not empty 

// Find last node /
Node last = (start).prev; 

// Create Node dynamically 
Node new_node = new Node(); 
new_node.data = value; 

// Start is going to be next of new_node 
new_node.next = start; 

// Make new node previous of start 
(start).prev = new_node; 

// Make last previous of new node 
new_node.prev = last; 

// Make new node next of old last 
last.next = new_node; 

return start;

}

// Function to display the // circular doubly linked list static void displayList(Node start) { Node temp = start;

while (temp.next != start) 
{ 
    System.out.printf("%d ", temp.data); 
    temp = temp.next; 
} 
System.out.printf("%d ", temp.data);

}

// Function to search the particular element // from the list static int searchList(Node start, int search) { // Declare the temp variable Node temp = start;

// Declare other control 
// variable for the searching 
int count = 0, flag = 0, value; 

// If start is null return -1 
if(temp == null) 
    return -1; 
else
{ 
    // Move the temp pointer until, 
    // temp.next doesn't move 
    // start address (Circular Fashion) 
    while(temp.next != start) 
    { 
        // Increment count for location 
        count++; 
        
        // If it is found raise the 
        // flag and break the loop 
        if(temp.data == search) 
        { 
            flag = 1; 
            count--; 
            break; 
        } 
        
        // Increment temp pointer 
        temp = temp.next; 
    } 
    
    // Check whether last element in the 
    // list content the value if contain, 
    // raise a flag and increment count 
    if(temp.data == search) 
    { 
        count++; 
        flag = 1; 
    } 
    
    // If flag is true, then element 
    // found, else not 
    if(flag == 1) 
        System.out.println("\n"+search +" found at location "+ 
                                        count); 
    else
        System.out.println("\n"+search +" not found"); 
} 
return -1;

}

// Driver code public static void main(String args[]) { // Start with the empty list / Node start = null;

// Insert 4. So linked list becomes 4.null 
start= insertNode(start, 4); 

// Insert 5. So linked list becomes 4.5 
start= insertNode(start, 5); 

// Insert 7. So linked list 
// becomes 4.5.7 
start= insertNode(start, 7); 

// Insert 8. So linked list 
// becomes 4.5.7.8 
start= insertNode(start, 8); 

// Insert 6. So linked list 
// becomes 4.5.7.8.6 
start= insertNode(start, 6); 

System.out.printf("Created circular doubly linked list is: "); 
displayList(start); 

searchList(start, 5);

} }

// This code is contributed by Arnab Kundu

Python3

Python3 program to illustrate inserting a Node in

a Circular Doubly Linked list in begging, end

and middle

import math

Structure of a Node

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

Function to insert a node at the end

def insertNode(start, value):

# If the list is empty, create a single node 
# circular and doubly list 
if (start == None) : 
    new_node = Node(value) 
    new_node.data = value 
    new_node.next = new_node
    new_node.prev = new_node 
    start = new_node 
    return new_node

# If list is not empty 

# Find last node */
last = start.prev 

# Create Node dynamically 
new_node = Node(value) 
new_node.data = value 

# Start is going to be next of new_node 
new_node.next = start 

# Make new node previous of start 
(start).prev = new_node 

# Make last previous of new node 
new_node.prev = last 

# Make new node next of old last 
last.next = new_node
return start

Function to display the

circular doubly linked list

def displayList(start): temp = start

while (temp.next != start): 
    print(temp.data, end = " ") 
    temp = temp.next

print(temp.data)

Function to search the particular element

from the list

def searchList(start, search):

# Declare the temp variable
temp = start

# Declare other control
# variable for the searching
count = 0
flag = 0
value = 0

# If start is None return -1
if(temp == None):
    return -1
else:
    
    # Move the temp pointer until, 
    # temp.next doesn't move
    # start address (Circular Fashion)
    while(temp.next != start):
        
        # Increment count for location
        count = count + 1
        
        # If it is found raise the
        # flag and break the loop
        if(temp.data == search):
            flag = 1
            count = count - 1
            break
        
        # Increment temp pointer
        temp = temp.next
    
    # Check whether last element in the
    # list content the value if contain, 
    # raise a flag and increment count
    if(temp.data == search):
        count = count + 1
        flag = 1

    # If flag is true, then element
    # found, else not
    if(flag == 1):
        print(search,"found at location ", count)
    else:
        print(search, " not found")

return -1

Driver code

if name=='main':

# Start with the empty list */
start = None

# Insert 4. So linked list becomes 4.None 
start = insertNode(start, 4)

# Insert 5. So linked list becomes 4.5 
start = insertNode(start, 5) 

# Insert 7. So linked list 
# becomes 4.5.7 
start = insertNode(start, 7) 

# Insert 8. So linked list 
# becomes 4.5.7.8 
start = insertNode(start, 8) 

# Insert 6. So linked list 
# becomes 4.5.7.8.6 
start = insertNode(start, 6) 

print("Created circular doubly linked list is: ",
                                        end = "") 
displayList(start) 

searchList(start, 5)

This article contributed by Srathore

C#

// C# Program to Reverse a List using Data Swapping using System;

class GFG {

// Structure of a Node 
public class Node 
{ 
    public int data; 
    public Node next; 
    public Node prev; 
}; 

// Function to insert a node at the end 
static Node insertNode(Node start, int value) 
{ 
    // If the list is empty, create a single node 
    // circular and doubly list 
    Node new_node = new Node(); 
    if (start == null) 
    { 
        
        new_node.data = value; 
        new_node.next = new_node.prev = new_node; 
        start = new_node; 
        return new_node; 
    } 

    // If list is not empty 

    // Find last node /
    Node last = (start).prev; 

    // Create Node dynamically 
    new_node = new Node(); 
    new_node.data = value; 

    // Start is going to be next of new_node 
    new_node.next = start; 

    // Make new node previous of start 
    (start).prev = new_node; 

    // Make last previous of new node 
    new_node.prev = last; 

    // Make new node next of old last 
    last.next = new_node; 
    
    return start;
} 

// Function to display the 
// circular doubly linked list 
static void displayList(Node start) 
{ 
    Node temp = start; 

    while (temp.next != start) 
    { 
        Console.Write("{0} ", temp.data); 
        temp = temp.next; 
    } 
    Console.Write("{0} ", temp.data); 
} 

// Function to search the particular element 
// from the list 
static int searchList(Node start, int search) 
{ 
    // Declare the temp variable 
    Node temp = start; 
    
    // Declare other control 
    // variable for the searching 
    int count = 0, flag = 0, value; 
    
    // If start is null return -1 
    if(temp == null) 
        return -1; 
    else
    { 
        // Move the temp pointer until, 
        // temp.next doesn't move 
        // start address (Circular Fashion) 
        while(temp.next != start) 
        { 
            // Increment count for location 
            count++; 
            
            // If it is found raise the 
            // flag and break the loop 
            if(temp.data == search) 
            { 
                flag = 1; 
                count--; 
                break; 
            } 
            
            // Increment temp pointer 
            temp = temp.next; 
        } 
        
        // Check whether last element in the 
        // list content the value if contain, 
        // raise a flag and increment count 
        if(temp.data == search) 
        { 
            count++; 
            flag = 1; 
        } 
        
        // If flag is true, then element 
        // found, else not 
        if(flag == 1) 
            Console.WriteLine("\n"+search +" found at location "+ 
                                            count); 
        else
            Console.WriteLine("\n"+search +" not found"); 
    } 
    return -1;
} 

// Driver code 
public static void Main(String []args)
{ 
    // Start with the empty list /
    Node start = null; 

    // Insert 4. So linked list becomes 4.null 
    start= insertNode(start, 4); 

    // Insert 5. So linked list becomes 4.5 
    start= insertNode(start, 5); 

    // Insert 7. So linked list 
    // becomes 4.5.7 
    start= insertNode(start, 7); 

    // Insert 8. So linked list 
    // becomes 4.5.7.8 
    start= insertNode(start, 8); 

    // Insert 6. So linked list 
    // becomes 4.5.7.8.6 
    start= insertNode(start, 6); 

    Console.Write("Created circular doubly linked list is: "); 
    displayList(start); 
    
    searchList(start, 5); 
}

}

// This code has been contributed by 29AjayKumar

JavaScript

Output:

Created circular doubly linked list is: 4 5 7 8 6 5 found at location 2

Time Complexity: O(n), as we are using a loop to traverse n times. Where n is the number of nodes in the linked list.

Auxiliary Space: O(1), as we are not using any extra space.