Convert Binary Tree to Circular Doubly Linked List using Linear extra space

Last Updated : 28 Nov, 2022

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.

Create a temporary pointer that points to the current pointer.
Make a new node with the current element of the vector.
Make the current right point to this new node.
Make the current pointer the current right pointer.
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 <bits/stdc++.h> 
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[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[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<Integer> 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<Integer> 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[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.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

<script> 
// javascript program for conversion 
// of Binary Tree to CDLL 
  
// A binary tree node has data, 
// and left and right pointers 
    class Node { 
        constructor(val) { 
            this.data = val; 
            this.left = null; 
            this.right = null; 
        } 
    } 
  
    // Function to perform In-Order traversal of the 
    // tree and store the nodes in a vector 
    function inorder(root, v) { 
        if (root == null) 
            return; 
  
        /* first recur on left child */
        inorder(root.left, v); 
  
        /* append the data of node in vector */
        v.push(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 
    function bTreeToCList(root) { 
        // Base cases 
        if (root == null) 
            return null; 
  
        // Vector to be used for storing the nodes 
        // of tree in In-order form 
        var v = []; 
  
        // Calling the In-Order traversal function 
        inorder(root, v); 
  
        // Create the head of the linked list pointing 
        // to the root of the tree 
        var head_ref = new Node(v[0]); 
  
        // Create a current pointer to be used in traversal 
        var curr = head_ref; 
  
        // Traversing the nodes of the tree starting 
        // from the second elements 
        for (i = 1; i < v.length; i++) { 
  
            // Create a temporary pointer 
            // pointing to current 
            var 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 
    function displayCList(head) { 
        document.write("Circular Doubly Linked List is :<br/>"); 
  
        var itr = head; 
        do { 
            document.write(itr.data + " "); 
            itr = itr.right; 
        } while (head != itr); 
  
        document.write(); 
    } 
  
    // Driver Code 
      
    var 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); 
  
    var head = bTreeToCList(root); 
    displayCList(head); 
  
// This code contributed by Rajput-Ji 
</script> 

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)

Maximum sum of non-overlapping subarrays of length atmost K

Abhishek_Vashisht

Improve

Article Tags :

Practice Tags :

Convert Binary Tree to Circular Doubly Linked List using Linear extra space

C++

Java

Python

C#

Javascript

Similar Reads

Thank You!

What kind of Experience do you want to share?