Skip to content
Related Articles

Related Articles

Convert an Array to a Circular Doubly Linked List

View Discussion
Improve Article
Save Article
  • Difficulty Level : Basic
  • Last Updated : 23 Jun, 2022

Prerequisite: Doubly Linked list, Circular Linked List, Circular Doubly Linked List
Given an array of N elements. The task is to write a program to convert the array into a circular doubly linked list.
 

Image Representation

 

The idea is to start traversing the array and for every array element create a new list node and assign the prev and next pointers of this node accordingly. 
 

  • Create a pointer start to point to the starting of the list which will initially point to NULL(Empty list).
  • For the first element of the array, create a new node and put that node’s prev and next pointers to point to start maintaining the circular fashion of the list.
  • For the rest of the array elements, insert those elements to the end of the created circular doubly linked list.

Below is the implementation of the above idea: 
 

C++




// CPP program to convert array to
// circular doubly linked list
 
#include<bits/stdc++.h>
using namespace std;
 
// Doubly linked list node
struct node
{
    int data;
    struct node *next;
    struct node *prev;
};
 
// Utility function to create a node in memory
struct node* getNode()
{
    return ((struct node *)malloc(sizeof(struct node)));
}
 
// Function to display the list
int displayList(struct node *temp)
{
    struct node *t = temp;
    if(temp == NULL)
        return 0;
    else
    {  
        cout<<"The list is: ";
         
        while(temp->next != t)
        {
            cout<<temp->data<<" ";
            temp = temp->next;
        }
         
        cout<<temp->data;
         
        return 1;
    }
}
 
// Function to convert array into list
void createList(int arr[], int n, struct node **start)
{
    // Declare newNode and temporary pointer
    struct node *newNode,*temp;
    int i;
     
    // Iterate the loop until array length
    for(i=0;i<n;i++)
    {
        // Create new node
        newNode = getNode();
         
        // Assign the array data
        newNode->data = arr[i];
         
        // If it is first element
        // Put that node prev and next as start
        // as it is circular
        if(i==0)
        {
            *start = newNode;
            newNode->prev = *start;
            newNode->next = *start;
        }
        else
        {  
            // Find the last node
            temp = (*start)->prev;
             
            // Add the last node to make them
            // in circular fashion
            temp->next = newNode;
            newNode->next = *start;
            newNode->prev = temp;
            temp = *start;
            temp->prev = newNode;
        }
    }
}
 
// Driver Code
int main()
{
    // Array to be converted
    int arr[] = {1,2,3,4,5};
    int n = sizeof(arr) / sizeof(arr[0]);
     
    // Start Pointer
    struct node *start = NULL;
     
    // Create the List
    createList(arr, n, &start);
     
    // Display the list
    displayList(start);
     
    return 0;
}

Java




// Java program to convert array to
// circular doubly linked list
class GFG
{
     
// Doubly linked list node
static class node
{
    int data;
    node next;
    node prev;
};
 
// Utility function to create a node in memory
static node getNode()
{
    return new node();
}
 
// Function to display the list
static int displayList( node temp)
{
    node t = temp;
    if(temp == null)
        return 0;
    else
    {
        System.out.print("The list is: ");
         
        while(temp.next != t)
        {
            System.out.print(temp.data+" ");
            temp = temp.next;
        }
         
        System.out.print(temp.data);
         
        return 1;
    }
}
 
// Function to convert array into list
static node createList(int arr[], int n, node start)
{
    // Declare newNode and temporary pointer
    node newNode,temp;
    int i;
     
    // Iterate the loop until array length
    for(i = 0; i < n; i++)
    {
        // Create new node
        newNode = getNode();
         
        // Assign the array data
        newNode.data = arr[i];
         
        // If it is first element
        // Put that node prev and next as start
        // as it is circular
        if(i == 0)
        {
            start = newNode;
            newNode.prev = start;
            newNode.next = start;
        }
        else
        {
            // Find the last node
            temp = (start).prev;
             
            // Add the last node to make them
            // in circular fashion
            temp.next = newNode;
            newNode.next = start;
            newNode.prev = temp;
            temp = start;
            temp.prev = newNode;
        }
    }
    return start;
}
 
// Driver Code
public static void main(String args[])
{
    // Array to be converted
    int arr[] = {1,2,3,4,5};
    int n = arr.length;
     
    // Start Pointer
    node start = null;
     
    // Create the List
    start = createList(arr, n, start);
     
    // Display the list
    displayList(start);
}
}
 
// This code is contributed by Arnab Kundu

Python3




# Python3 program to convert array to
# circular doubly linked list
 
# Node of the doubly linked list
class Node:
     
    def __init__(self, data):
        self.data = data
        self.prev = None
        self.next = None
 
# Utility function to create a node in memory
def getNode():
 
    return (Node(0))
 
# Function to display the list
def displayList(temp):
 
    t = temp
    if(temp == None):
        return 0
    else:
         
        print("The list is: ", end = " ")
         
        while(temp.next != t):
         
            print(temp.data, end = " ")
            temp = temp.next
         
        print(temp.data)
         
        return 1
     
# Function to convert array into list
def createList(arr, n, start):
 
    # Declare newNode and temporary pointer
    newNode = None
    temp = None
    i = 0
     
    # Iterate the loop until array length
    while(i < n):
     
        # Create new node
        newNode = getNode()
         
        # Assign the array data
        newNode.data = arr[i]
         
        # If it is first element
        # Put that node prev and next as start
        # as it is circular
        if(i == 0):
         
            start = newNode
            newNode.prev = start
            newNode.next = start
         
        else:
             
            # Find the last node
            temp = (start).prev
             
            # Add the last node to make them
            # in circular fashion
            temp.next = newNode
            newNode.next = start
            newNode.prev = temp
            temp = start
            temp.prev = newNode
        i = i + 1
    return start
 
# Driver Code
if __name__ == "__main__":
 
    # Array to be converted
    arr = [1, 2, 3, 4, 5]
    n = len(arr)
     
    # Start Pointer
    start = None
     
    # Create the List
    start = createList(arr, n, start)
     
    # Display the list
    displayList(start)
     
# This code is contributed by Arnab Kundu

C#




// C# program to convert array to
// circular doubly linked list
using System;
 
class GFG
{
     
// Doubly linked list node
public class node
{
    public int data;
    public node next;
    public node prev;
};
 
// Utility function to create a node in memory
static node getNode()
{
    return new node();
}
 
// Function to display the list
static int displayList( node temp)
{
    node t = temp;
    if(temp == null)
        return 0;
    else
    {
        Console.Write("The list is: ");
         
        while(temp.next != t)
        {
            Console.Write(temp.data + " ");
            temp = temp.next;
        }
         
        Console.Write(temp.data);
         
        return 1;
    }
}
 
// Function to convert array into list
static node createList(int []arr,
                        int n, node start)
{
    // Declare newNode and temporary pointer
    node newNode,temp;
    int i;
     
    // Iterate the loop until array length
    for(i = 0; i < n; i++)
    {
        // Create new node
        newNode = getNode();
         
        // Assign the array data
        newNode.data = arr[i];
         
        // If it is first element
        // Put that node prev and next as start
        // as it is circular
        if(i == 0)
        {
            start = newNode;
            newNode.prev = start;
            newNode.next = start;
        }
        else
        {
            // Find the last node
            temp = (start).prev;
             
            // Add the last node to make them
            // in circular fashion
            temp.next = newNode;
            newNode.next = start;
            newNode.prev = temp;
            temp = start;
            temp.prev = newNode;
        }
    }
    return start;
}
 
// Driver Code
public static void Main(String []args)
{
    // Array to be converted
    int []arr = {1,2,3,4,5};
    int n = arr.Length;
     
    // Start Pointer
    node start = null;
     
    // Create the List
    start = createList(arr, n, start);
     
    // Display the list
    displayList(start);
}
}
 
// This code contributed by Rajput-Ji

Javascript




<script>
 
// JavaScript program to convert array to
// circular doubly linked list
 
// Doubly linked list node
class node
{
    constructor()
    {
        this.data=0;
        this.next=this.prev=null;
    }
}
 
// Utility function to create a node in memory
function getNode()
{
    return new node();
}
 
// Function to display the list
function displayList(temp)
{
    let t = temp;
    if(temp == null)
        return 0;
    else
    {
        document.write("The list is: ");
           
        while(temp.next != t)
        {
            document.write(temp.data+" ");
            temp = temp.next;
        }
           
        document.write(temp.data);
           
        return 1;
    }
}
 
// Function to convert array into list
function createList(arr,n,start)
{
    // Declare newNode and temporary pointer
    let newNode,temp;
    let i;
       
    // Iterate the loop until array length
    for(i = 0; i < n; i++)
    {
        // Create new node
        newNode = getNode();
           
        // Assign the array data
        newNode.data = arr[i];
           
        // If it is first element
        // Put that node prev and next as start
        // as it is circular
        if(i == 0)
        {
            start = newNode;
            newNode.prev = start;
            newNode.next = start;
        }
        else
        {
            // Find the last node
            temp = (start).prev;
               
            // Add the last node to make them
            // in circular fashion
            temp.next = newNode;
            newNode.next = start;
            newNode.prev = temp;
            temp = start;
            temp.prev = newNode;
        }
    }
    return start;
}
 
// Driver Code
let arr=[1,2,3,4,5];
let n = arr.length;
// Start Pointer
let start = null;
 
// Create the List
start = createList(arr, n, start);
 
// Display the list
displayList(start);
 
 
// This code is contributed by avanitrachhadiya2155
 
</script>

Output: 

The list is: 1 2 3 4 5

 

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.


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!