# Convert a given Binary Tree to Circular Doubly Linked List | Set 2

• Difficulty Level : Easy
• Last Updated : 21 May, 2021

Given a Binary Tree, convert it to a Circular Doubly Linked List.

• The left and right pointers in nodes are to be used as previous and next pointers, respectively, in the converted Circular Linked List.
• The order of nodes in the List must be the same as in the order of the given Binary Tree.
• The first node of Inorder traversal must be the head node of the Circular List.

Example: An in-place solution to this problem is discussed in the previous post.
In this post, a much simpler solution, but using extra O(n) space, is discussed.
In this approach, first, we do an In-Order traversal of the given binary tree, we store this traversal in a vector, which will be passed on to the function along with the tree. Now, generate a circular doubly linked list from the elements of the vector.
To generate a circular doubly linked list from the vector, make the first element of the vector as the head of the linked list and also create a current pointer that is right now pointing to the head. Now start traversing the array from the second element and do the following.

1. Create a temporary pointer that points to the current pointer.
2. Make a new node with the current element of the vector.
3. Make the current right point to this new node.
4. Make the current pointer the current right pointer.
5. Now, finally, the current left point is a temporary pointer created in the first step.

Do this for all the elements and after the traversal is completed, make the current’s right (current is right now pointing to the last element of the vector) point to the head of the list and make the head’s left point to the current pointer. Finally, return the head.

Below is the implementation of the above approach:

## C++

 `// A C++ program for conversion``// of Binary Tree to CDLL` `#include ``using` `namespace` `std;` `// A binary tree node has data,``// and left and right pointers``struct` `Node {``    ``int` `data;``    ``struct` `Node* left;``    ``struct` `Node* right;` `    ``Node(``int` `x)``    ``{``        ``data = x;``        ``left = right = NULL;``    ``}``};` `// Function to perform In-Order traversal of the``// tree and store the nodes in a vector``void` `inorder(Node* root, vector<``int``>& v)``{``    ``if` `(!root)``        ``return``;` `    ``/* first recur on left child */``    ``inorder(root->left, v);` `    ``/* append the data of node in vector */``    ``v.push_back(root->data);` `    ``/* now recur on right child */``    ``inorder(root->right, v);``}` `// Function to convert Binary Tree to Circular``// Doubly Linked list using the vector which stores``// In-Order traversal of the Binary Tree``Node* bTreeToCList(Node* root)``{``    ``// Base cases``    ``if` `(root == NULL)``        ``return` `NULL;` `    ``// Vector to be used for storing the nodes``    ``// of tree in In-order form``    ``vector<``int``> v;` `    ``// Calling the In-Order traversal function``    ``inorder(root, v);` `    ``// Create the head of the linked list pointing``    ``// to the root of the tree``    ``Node* head_ref = ``new` `Node(v);` `    ``// Create a current pointer to be used in traversal``    ``Node* curr = head_ref;` `    ``// Traversing the nodes of the tree starting``    ``// from the second elements``    ``for` `(``int` `i = 1; i < v.size(); i++) {` `        ``// Create a temporary pointer``        ``// pointing to current``        ``Node* temp = curr;` `        ``// Current's right points to the current``        ``// node in traversal``        ``curr->right = ``new` `Node(v[i]);` `        ``// Current points to its right``        ``curr = curr->right;` `        ``// Current's left points to temp``        ``curr->left = temp;``    ``}` `    ``// Current's right points to head of the list``    ``curr->right = head_ref;` `    ``// Head's left points to current``    ``head_ref->left = curr;` `    ``// Return head of the list``    ``return` `head_ref;``}` `// Display Circular Link List``void` `displayCList(Node* head)``{``    ``cout << ``"Circular Doubly Linked List is :\n"``;` `    ``Node* itr = head;``    ``do` `{``        ``cout << itr->data << ``" "``;``        ``itr = itr->right;``    ``} ``while` `(head != itr);` `    ``cout << ``"\n"``;``}` `// Driver Code``int` `main()``{``    ``Node* root = ``new` `Node(10);``    ``root->left = ``new` `Node(12);``    ``root->right = ``new` `Node(15);``    ``root->left->left = ``new` `Node(25);``    ``root->left->right = ``new` `Node(30);``    ``root->right->left = ``new` `Node(36);` `    ``Node* head = bTreeToCList(root);``    ``displayCList(head);` `    ``return` `0;``}`

## Java

 `// Java program for conversion``// of Binary Tree to CDLL``import` `java.util.*;``class` `GFG``{` `// A binary tree node has data,``// and left and right pointers``static` `class` `Node``{ ``    ``int` `data;``    ``Node left;``    ``Node right;` `    ``Node(``int` `x)``    ``{``        ``data = x;``        ``left = right = ``null``;``    ``}``};` `// Function to perform In-Order traversal of the``// tree and store the nodes in a vector``static` `void` `inorder(Node root, Vector v)``{``    ``if` `(root == ``null``)``        ``return``;` `    ``/* first recur on left child */``    ``inorder(root.left, v);` `    ``/* append the data of node in vector */``    ``v.add(root.data);` `    ``/* now recur on right child */``    ``inorder(root.right, v);``}` `// Function to convert Binary Tree to Circular``// Doubly Linked list using the vector which stores``// In-Order traversal of the Binary Tree``static` `Node bTreeToCList(Node root)``{``    ``// Base cases``    ``if` `(root == ``null``)``        ``return` `null``;` `    ``// Vector to be used for storing the nodes``    ``// of tree in In-order form``    ``Vector v = ``new` `Vector<>();` `    ``// Calling the In-Order traversal function``    ``inorder(root, v);` `    ``// Create the head of the linked list pointing``    ``// to the root of the tree``    ``Node head_ref = ``new` `Node(v.get(``0``));` `    ``// Create a current pointer to be used in traversal``    ``Node curr = head_ref;` `    ``// Traversing the nodes of the tree starting``    ``// from the second elements``    ``for` `(``int` `i = ``1``; i < v.size(); i++)``    ``{` `        ``// Create a temporary pointer``        ``// pointing to current``        ``Node temp = curr;` `        ``// Current's right points to the current``        ``// node in traversal``        ``curr.right = ``new` `Node(v.get(i));` `        ``// Current points to its right``        ``curr = curr.right;` `        ``// Current's left points to temp``        ``curr.left = temp;``    ``}` `    ``// Current's right points to head of the list``    ``curr.right = head_ref;` `    ``// Head's left points to current``    ``head_ref.left = curr;` `    ``// Return head of the list``    ``return` `head_ref;``}` `// Display Circular Link List``static` `void` `displayCList(Node head)``{``    ``System.out.println(``"Circular Doubly Linked List is :"``);` `    ``Node itr = head;``    ``do``    ``{``        ``System.out.print(itr.data + ``" "``);``        ``itr = itr.right;``    ``} ``while` `(head != itr);` `    ``System.out.println();``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``Node root = ``new` `Node(``10``);``    ``root.left = ``new` `Node(``12``);``    ``root.right = ``new` `Node(``15``);``    ``root.left.left = ``new` `Node(``25``);``    ``root.left.right = ``new` `Node(``30``);``    ``root.right.left = ``new` `Node(``36``);` `    ``Node head = bTreeToCList(root);``    ``displayCList(head);``}``}` `// This code is contributed by Rajput-Ji`

## Python

 `# Python program for conversion``# of Binary Tree to CDLL` `# A binary tree node has data,``# and left and right pointers``class` `Node:``    ``def` `__init__(``self``, data):``        ``self``.data ``=` `data``        ``self``.left ``=` `self``.right ``=` `None` `v ``=` `[]` `# Function to perform In-Order traversal of the``# tree and store the nodes in a vector``def` `inorder(root):``    ``global` `v``    ` `    ``if` `(root ``=``=` `None``):``        ``return` `    ``# first recur on left child``    ``inorder(root.left)` `    ``# append the data of node in vector``    ``v.append(root.data)` `    ``# now recur on right child``    ``inorder(root.right)` `# Function to convert Binary Tree to Circular``# Doubly Linked list using the vector which stores``# In-Order traversal of the Binary Tree``def` `bTreeToCList(root):` `    ``global` `v``    ` `    ``# Base cases``    ``if` `(root ``=``=` `None``):``        ``return` `None` `    ``# Vector to be used for storing the nodes``    ``# of tree in In-order form``    ``v ``=` `[]` `    ``# Calling the In-Order traversal function``    ``inorder(root)` `    ``# Create the head of the linked list pointing``    ``# to the root of the tree``    ``head_ref ``=` `Node(v[``0``])` `    ``# Create a current pointer to be used in traversal``    ``curr ``=` `head_ref` `    ``i ``=` `1``    ` `    ``# Traversing the nodes of the tree starting``    ``# from the second elements``    ``while` `( i < ``len``(v)) :``    ` `        ` `        ``# Create a temporary pointer``        ``# pointing to current``        ``temp ``=` `curr` `        ``# Current's right points to the current``        ``# node in traversal``        ``curr.right ``=` `Node(v[i])` `        ``# Current points to its right``        ``curr ``=` `curr.right` `        ``# Current's left points to temp``        ``curr.left ``=` `temp``        ``i ``=` `i ``+` `1` `    ``# Current's right points to head of the list``    ``curr.right ``=` `head_ref` `    ``# Head's left points to current``    ``head_ref.left ``=` `curr` `    ``# Return head of the list``    ``return` `head_ref` `# Display Circular Link List``def` `displayCList(head):` `    ``print``(``"Circular Doubly Linked List is :"``, end ``=` `"")` `    ``itr ``=` `head``    ``while``(``True``):``        ``print``(itr.data, end ``=` `" "``)``        ``itr ``=` `itr.right``        ``if``(head ``=``=` `itr):``            ``break` `    ``print``()` `# Driver Code``root ``=` `Node(``10``)``root.left ``=` `Node(``12``)``root.right ``=` `Node(``15``)``root.left.left ``=` `Node(``25``)``root.left.right ``=` `Node(``30``)``root.right.left ``=` `Node(``36``)` `head ``=` `bTreeToCList(root)``displayCList(head)` `# This code is contributed by Arnab Kundu`

## C#

 `// C# program for conversion``// of Binary Tree to CDLL``using` `System;``using` `System.Collections.Generic;` `class` `GFG``{` `// A binary tree node has data,``// and left and right pointers``public` `class` `Node``{``    ``public` `int` `data;``    ``public` `Node left;``    ``public` `Node right;` `    ``public` `Node(``int` `x)``    ``{``        ``data = x;``        ``left = right = ``null``;``    ``}``};` `// Function to perform In-Order traversal of the``// tree and store the nodes in a vector``static` `void` `inorder(Node root, List<``int``> v)``{``    ``if` `(root == ``null``)``        ``return``;` `    ``/* first recur on left child */``    ``inorder(root.left, v);` `    ``/* append the data of node in vector */``    ``v.Add(root.data);` `    ``/* now recur on right child */``    ``inorder(root.right, v);``}` `// Function to convert Binary Tree to Circular``// Doubly Linked list using the vector which stores``// In-Order traversal of the Binary Tree``static` `Node bTreeToCList(Node root)``{``    ``// Base cases``    ``if` `(root == ``null``)``        ``return` `null``;` `    ``// Vector to be used for storing the nodes``    ``// of tree in In-order form``    ``List<``int``> v = ``new` `List<``int``>();` `    ``// Calling the In-Order traversal function``    ``inorder(root, v);` `    ``// Create the head of the linked list``    ``// pointing to the root of the tree``    ``Node head_ref = ``new` `Node(v);` `    ``// Create a current pointer``    ``// to be used in traversal``    ``Node curr = head_ref;` `    ``// Traversing the nodes of the tree starting``    ``// from the second elements``    ``for` `(``int` `i = 1; i < v.Count; i++)``    ``{` `        ``// Create a temporary pointer``        ``// pointing to current``        ``Node temp = curr;` `        ``// Current's right points to the current``        ``// node in traversal``        ``curr.right = ``new` `Node(v[i]);` `        ``// Current points to its right``        ``curr = curr.right;` `        ``// Current's left points to temp``        ``curr.left = temp;``    ``}` `    ``// Current's right points to head of the list``    ``curr.right = head_ref;` `    ``// Head's left points to current``    ``head_ref.left = curr;` `    ``// Return head of the list``    ``return` `head_ref;``}` `// Display Circular Link List``static` `void` `displayCList(Node head)``{``    ``Console.WriteLine(``"Circular Doubly "` `+``                      ``"Linked List is :"``);` `    ``Node itr = head;``    ``do``    ``{``        ``Console.Write(itr.data + ``" "``);``        ``itr = itr.right;``    ``} ``while` `(head != itr);` `    ``Console.WriteLine();``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``    ``Node root = ``new` `Node(10);``    ``root.left = ``new` `Node(12);``    ``root.right = ``new` `Node(15);``    ``root.left.left = ``new` `Node(25);``    ``root.left.right = ``new` `Node(30);``    ``root.right.left = ``new` `Node(36);` `    ``Node head = bTreeToCList(root);``    ``displayCList(head);``}``}` `// This code is contributed by 29AjayKumar`

## Javascript

 ``

Output:

```Circular Doubly Linked List is :
25 12 30 10 36 15```

Time Complexity: O(N), where N is the number of nodes in the Binary Tree.
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up