Convert a Binary Tree to a Circular Doubly Link List

Given a Binary Tree, convert it to a Circular Doubly Linked List (In-Place).

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

Example:
tree to list

The idea can be described using below steps.
1) Write a general purpose function that concatenates two given circular doubly lists (This function is explained below).
2) Now traverse the given tree
….a) Recursively convert left subtree to a circular DLL. Let the converted list be leftList.
….a) Recursively convert right subtree to a circular DLL. Let the converted list be rightList.
….c) Make a circular linked list of root of the tree, make left and right of root to point to itself.
….d) Concatenate leftList with list of single root node.
….e) Concatenate the list produced in step above (d) with rightList.



Note that the above code traverses tree in Postorder fashion. We can traverse in inorder fashion also. We can first concatenate left subtree and root, then recur for right subtree and concatenate the result with left-root concatenation.

How to Concatenate two circular DLLs?

  • Get the last node of the left list. Retrieving the last node is an O(1) operation, since the prev pointer of the head points to the last node of the list.
  • Connect it with the first node of the right list
  • Get the last node of the second list
  • Connect it with the head of the list.

Below are implementations of above idea.

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ Program to convert a Binary Tree
// to a Circular Doubly Linked List
#include<iostream>
using namespace std;
  
// To represents a node of a Binary Tree
struct Node
{
    struct Node *left, *right;
    int data;
};
  
// A function that appends rightList at the end
// of leftList.
Node *concatenate(Node *leftList, Node *rightList)
{
    // If either of the list is empty
    // then return the other list
    if (leftList == NULL)
        return rightList;
    if (rightList == NULL)
        return leftList;
  
    // Store the last Node of left List
    Node *leftLast = leftList->left;
  
    // Store the last Node of right List
    Node *rightLast = rightList->left;
  
    // Connect the last node of Left List
    // with the first Node of the right List
    leftLast->right = rightList;
    rightList->left = leftLast;
  
    // Left of first node points to
    // the last node in the list
    leftList->left = rightLast;
  
    // Right of last node refers to the first
    // node of the List
    rightLast->right = leftList;
  
    return leftList;
}
  
// Function converts a tree to a circular Linked List
// and then returns the head of the Linked List
Node *bTreeToCList(Node *root)
{
    if (root == NULL)
        return NULL;
  
    // Recursively convert left and right subtrees
    Node *left = bTreeToCList(root->left);
    Node *right = bTreeToCList(root->right);
  
    // Make a circular linked list of single node
    // (or root). To do so, make the right and
    // left pointers of this node point to itself
    root->left = root->right = root;
  
    // Step 1 (concatenate the left list with the list 
    //         with single node, i.e., current node)
    // Step 2 (concatenate the returned list with the
    //         right List)
    return concatenate(concatenate(left, root), right);
}
  
// Display Circular Link List
void displayCList(Node *head)
{
    cout << "Circular Linked List is :\n";
    Node *itr = head;
    do
    {
        cout << itr->data <<" ";
        itr = itr->right;
    } while (head!=itr);
    cout << "\n";
}
  
  
// Create a new Node and return its address
Node *newNode(int data)
{
    Node *temp = new Node();
    temp->data = data;
    temp->left = temp->right = NULL;
    return temp;
}
  
// Driver Program to test above function
int main()
{
    Node *root = newNode(10);
    root->left = newNode(12);
    root->right = newNode(15);
    root->left->left = newNode(25);
    root->left->right = newNode(30);
    root->right->left = newNode(36);
  
    Node *head = bTreeToCList(root);
    displayCList(head);
  
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java Program to convert a Binary Tree to a
// Circular Doubly Linked List
  
// Node class represents a Node of a Tree
class Node
{
    int val;
    Node left,right;
  
    public Node(int val)
    {
        this.val = val;
        left = right = null;
    }
}
  
// A class to represent a tree
class Tree
{
    Node root;
    public Tree()
    {
        root = null;
    }
  
    // concatenate both the lists and returns the head
    // of the List
    public Node concatenate(Node leftList,Node rightList)
    {
        // If either of the list is empty, then
        // return the other list
        if (leftList == null)
            return rightList;
        if (rightList == null)
            return leftList;
  
        // Store the last Node of left List
        Node leftLast = leftList.left;
  
        // Store the last Node of right List
        Node rightLast = rightList.left;
  
        // Connect the last node of Left List
        // with the first Node of the right List
        leftLast.right = rightList;
        rightList.left = leftLast;
  
        // left of first node refers to
        // the last node in the list
        leftList.left = rightLast;
  
        // Right of last node refers to the first
        // node of the List
        rightLast.right = leftList;
  
        // Return the Head of the List
        return leftList;
    }
  
    // Method converts a tree to a circular
    // Link List and then returns the head
    // of the Link List
    public Node bTreeToCList(Node root)
    {
        if (root == null)
            return null;
  
        // Recursively convert left and right subtrees
        Node left = bTreeToCList(root.left);
        Node right = bTreeToCList(root.right);
  
        // Make a circular linked list of single node
        // (or root). To do so, make the right and
        // left pointers of this node point to itself
        root.left = root.right = root;
  
        // Step 1 (concatenate the left list with the list 
        //         with single node, i.e., current node)
        // Step 2 (concatenate the returned list with the
        //         right List)
        return concatenate(concatenate(left, root), right);
    }
  
    // Display Circular Link List
    public void display(Node head)
    {
        System.out.println("Circular Linked List is :");
        Node itr = head;
        do
        {
            System.out.print(itr.val+ " " );
            itr = itr.right;
        }
        while (itr != head);
        System.out.println();
    }
}
  
// Driver Code
class Main
{
    public static void main(String args[])
    {
        // Build the tree
        Tree tree = new Tree();
        tree.root = new Node(10);
        tree.root.left = new Node(12);
        tree.root.right = new Node(15);
        tree.root.left.left = new Node(25);
        tree.root.left.right = new Node(30);
        tree.root.right.left = new Node(36);
  
        // head refers to the head of the Link List
        Node head = tree.bTreeToCList(tree.root);
  
        // Display the Circular LinkedList
        tree.display(head);
    }
}

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 Program to convert a Binary 
# Tree to a Circular Doubly Linked List 
  
class newNode:
    def __init__(self, data):
        self.data = data
        self.left = self.right = None
          
# A function that appends rightList 
# at the end of leftList. 
def concatenate(leftList, rightList):
      
    # If either of the list is empty 
    # then return the other list 
    if (leftList == None):
        return rightList 
    if (rightList == None): 
        return leftList 
  
    # Store the last Node of left List 
    leftLast = leftList.left 
  
    # Store the last Node of right List 
    rightLast = rightList.left 
  
    # Connect the last node of Left List 
    # with the first Node of the right List 
    leftLast.right = rightList 
    rightList.left = leftLast 
  
    # Left of first node points to 
    # the last node in the list 
    leftList.left = rightLast 
  
    # Right of last node refers to 
    # the first node of the List 
    rightLast.right = leftList 
  
    return leftList
  
# Function converts a tree to a circular 
# Linked List and then returns the head 
# of the Linked List 
def bTreeToCList(root):
    if (root == None): 
        return None
  
    # Recursively convert left and 
    # right subtrees 
    left = bTreeToCList(root.left) 
    right = bTreeToCList(root.right) 
  
    # Make a circular linked list of single 
    # node (or root). To do so, make the 
    # right and left pointers of this node
    # point to itself 
    root.left = root.right = root 
  
    # Step 1 (concatenate the left list 
    #          with the list with single 
    #         node, i.e., current node) 
    # Step 2 (concatenate the returned list
    #          with the right List) 
    return concatenate(concatenate(left, 
                            root), right)
  
# Display Circular Link List 
def displayCList(head):
    print("Circular Linked List is :"
    itr = head
    first = 1
    while (head != itr or first):
        print(itr.data, end = " "
        itr = itr.right
        first = 0
    print()
  
# Driver Code
if __name__ == '__main__':
    root = newNode(10
    root.left = newNode(12
    root.right = newNode(15
    root.left.left = newNode(25
    root.left.right = newNode(30
    root.right.left = newNode(36
  
    head = bTreeToCList(root) 
    displayCList(head) 
      
# This code is contributed by PranchalK

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# Program to convert a Binary Tree 
// to a Circular Doubly Linked List 
using System;
  
// Node class represents a Node of a Tree 
public class Node
{
    public int val;
    public Node left, right;
  
    public Node(int val)
    {
        this.val = val;
        left = right = null;
    }
}
  
// A class to represent a tree 
public class Tree
{
    internal Node root;
    public Tree()
    {
        root = null;
    }
  
    // concatenate both the lists 
    // and returns the head of the List 
    public virtual Node concatenate(Node leftList, 
                                    Node rightList)
    {
        // If either of the list is empty, 
        // then return the other list 
        if (leftList == null)
        {
            return rightList;
        }
        if (rightList == null)
        {
            return leftList;
        }
  
        // Store the last Node of left List 
        Node leftLast = leftList.left;
  
        // Store the last Node of right List 
        Node rightLast = rightList.left;
  
        // Connect the last node of Left List 
        // with the first Node of the right List 
        leftLast.right = rightList;
        rightList.left = leftLast;
  
        // left of first node refers to 
        // the last node in the list 
        leftList.left = rightLast;
  
        // Right of last node refers to 
        // the first node of the List 
        rightLast.right = leftList;
  
        // Return the Head of the List 
        return leftList;
    }
  
    // Method converts a tree to a circular 
    // Link List and then returns the head 
    // of the Link List 
    public virtual Node bTreeToCList(Node root)
    {
        if (root == null)
        {
            return null;
        }
  
        // Recursively convert left 
        // and right subtrees 
        Node left = bTreeToCList(root.left);
        Node right = bTreeToCList(root.right);
  
        // Make a circular linked list of single 
        // node (or root). To do so, make the 
        // right and left pointers of this node 
        // point to itself 
        root.left = root.right = root;
  
        // Step 1 (concatenate the left list with
        //          the list with single node,
        //        i.e., current node) 
        // Step 2 (concatenate the returned list 
        //           with the right List) 
        return concatenate(concatenate(left, root), right);
    }
  
    // Display Circular Link List 
    public virtual void display(Node head)
    {
        Console.WriteLine("Circular Linked List is :");
        Node itr = head;
        do
        {
            Console.Write(itr.val + " ");
            itr = itr.right;
        } while (itr != head);
        Console.WriteLine();
    }
}
  
// Driver Code 
public class GFG
{
    public static void Main(string[] args)
    {
        // Build the tree 
        Tree tree = new Tree();
        tree.root = new Node(10);
        tree.root.left = new Node(12);
        tree.root.right = new Node(15);
        tree.root.left.left = new Node(25);
        tree.root.left.right = new Node(30);
        tree.root.right.left = new Node(36);
  
        // head refers to the head of the Link List 
        Node head = tree.bTreeToCList(tree.root);
  
        // Display the Circular LinkedList 
        tree.display(head);
    }
}
  
// This code is contributed by Shrikant13

chevron_right



Output:

Circular Linked List is :
25 12 30 10 36 15

This article is contributed by Chirag Agarwal. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.



My Personal Notes arrow_drop_up