Search an Element in Doubly Circular Linked List

Last Updated : 23 Jun, 2022

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# 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

<script>

// JavaScript program to illustrate inserting  
// a Node in a Circular Doubly Linked list 
// in begging, end and middle 

class Node 
{
    constructor()
    {
        this.data=0;
        this.next=this.prev=null;
    }
}

// Function to insert a node at the end
function insertNode(start,value)
{
    // If the list is empty, create a single node 
    // circular and doubly list 
    if (start == null) 
    { 
        let 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 /
    let last = (start).prev; 
  
    // Create Node dynamically 
    let 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 
function displayList(start)
{
    let temp = start; 
  
    while (temp.next != start) 
    { 
        document.write(temp.data+" "); 
        temp = temp.next; 
    } 
    document.write(temp.data+" ");
}

// Function to search the particular element 
// from the list 
function searchList(start,search)
{
    // Declare the temp variable 
    let temp = start; 
      
    // Declare other control 
    // variable for the searching 
    let 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) 
            document.write("<br>"+search +" found at location "+ 
                                            count); 
        else
            document.write("<br>"+search +" not found"); 
    } 
    return -1;
}

// Driver code 
// Start with the empty list /
let 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); 

document.write("Created circular doubly linked list is: "); 
displayList(start); 

searchList(start, 5); 


// This code is contributed by avanitrachhadiya2155

</script>

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.

Next Greater Element in a Circular Linked List

bilal-hungund

Improve

Article Tags :

Practice Tags :

Search an Element in Doubly Circular Linked List

Similar Reads

Thank You!

What kind of Experience do you want to share?