Skip to content
Related Articles
Get the best out of our app
GeeksforGeeks App
Open App
geeksforgeeks
Browser
Continue

Related Articles

Double Tree

Improve Article
Save Article
Like Article
Improve Article
Save Article
Like Article

Write a program that converts a given tree to its Double tree. To create Double tree of the given tree, create a new duplicate for each node, and insert the duplicate as the left child of the original node. 
So the tree… 

    2
   / \
  1   3

is changed to…  

       2
      / \
     2   3
    /   /
   1   3
  /
 1

And the tree 

            1
          /   \
        2      3
      /  \
    4     5

is changed to 

               1
             /   \
           1      3
          /      /
        2       3
      /  \
     2    5
    /    /
   4   5
  /   
 4

Recursive approach: : Recursively convert the tree to double tree in postorder fashion. For each node, first convert the left subtree of the node, then right subtree, finally create a duplicate node of the node and fix the left child of the node and left child of left child.

Below is the implementation of the above approach:

C++




// C++ program to convert binary tree to double tree
#include <bits/stdc++.h>
using namespace std;
 
/* A binary tree node has data,
pointer to left child and a
pointer to right child */
class node
{
    public:
    int data;
    node* left;
    node* right;
};
 
/* function to create a new
node of tree and returns pointer */
node* newNode(int data);
 
/* Function to convert a tree to double tree */
void doubleTree(node* Node)
{
    node* oldLeft;
     
    if (Node == NULL) return;
     
    /* do the subtrees */
    doubleTree(Node->left);
    doubleTree(Node->right);
     
    /* duplicate this node to its left */
    oldLeft = Node->left;
    Node->left = newNode(Node->data);
    Node->left->left = oldLeft;
}
 
/* UTILITY FUNCTIONS TO TEST doubleTree() FUNCTION */
/* Helper function that allocates a new node with the
given data and NULL left and right pointers. */
node* newNode(int data)
{
    node* Node = new node();
    Node->data = data;
    Node->left = NULL;
    Node->right = NULL;
     
    return(Node);
}
 
/* Given a binary tree, print its nodes in inorder*/
void printInorder(node* node)
{
    if (node == NULL)
        return;
    printInorder(node->left);
    cout << node->data << " ";
    printInorder(node->right);
}
 
/* Driver code*/
int main()
{
    /* Constructed binary tree is
                1
            / \
            2 3
        / \
        4 5
    */
    node *root = newNode(1);
    root->left = newNode(2);
    root->right = newNode(3);
    root->left->left = newNode(4);
    root->left->right = newNode(5);
     
    cout << "Inorder traversal of the original tree is \n";
    printInorder(root);
     
    doubleTree(root);
         
    cout << "\nInorder traversal of the double tree is \n";
    printInorder(root);
     
    return 0;
}
 
// This code is contributed by rathbhupendra

C



#include <stdio.h>
#include <stdlib.h>
  
/* A binary tree node has data, pointer to left child
   and a pointer to right child */
struct node
{
    int data;
    struct node* left;
    struct node* right;
};
  
/* function to create a new node of tree and returns pointer */
struct node* newNode(int data);
  
/* Function to convert a tree to double tree */
void doubleTree(struct node* node)
{
  struct node* oldLeft;
 
  if (node==NULL) return;
 
  /* do the subtrees */
  doubleTree(node->left);
  doubleTree(node->right);
 
  /* duplicate this node to its left */
  oldLeft = node->left;
  node->left = newNode(node->data);
  node->left->left = oldLeft;
}
   
 
  
/* UTILITY FUNCTIONS TO TEST doubleTree() FUNCTION */
 /* Helper function that allocates a new node with the
   given data and NULL left and right pointers. */
struct node* newNode(int data)
{
  struct node* node = (struct node*)
                       malloc(sizeof(struct node));
  node->data = data;
  node->left = NULL;
  node->right = NULL;
  
  return(node);
}
 
/* Given a binary tree, print its nodes in inorder*/
void printInorder(struct node* node)
{
  if (node == NULL)
    return;
  printInorder(node->left);
  printf("%d ", node->data);
  printInorder(node->right);
}
  
  
/* Driver program to test above functions*/
int main()
{
  
  /* Constructed binary tree is
            1
          /   \
        2      3
      /  \
    4     5
  */
  struct node *root = newNode(1);
  root->left        = newNode(2);
  root->right       = newNode(3);
  root->left->left  = newNode(4);
  root->left->right = newNode(5);
  
  printf("Inorder traversal of the original tree is \n");
  printInorder(root);
 
  doubleTree(root);
   
  printf("\n Inorder traversal of the double tree is \n"); 
  printInorder(root);
    
  getchar();
  return 0;
}
Java



// Java program to convert binary tree to double tree
  
/* A binary tree node has data, pointer to left child
   and a pointer to right child */
class Node
{
    int data;
    Node left, right;
  
    Node(int item)
    {
        data = item;
        left = right = null;
    }
}
  
class BinaryTree
{
    Node root;
  
    /* Function to convert a tree to double tree */
    void doubleTree(Node node)
    {
        Node oldleft;
  
        if (node == null)
            return;
  
        /* do the subtrees */
        doubleTree(node.left);
        doubleTree(node.right);
  
        /* duplicate this node to its left */
        oldleft = node.left;
        node.left = new Node(node.data);
        node.left.left = oldleft;
    }
  
    /* Given a binary tree, print its nodes in inorder*/
    void printInorder(Node node)
    {
        if (node == null)
            return;
        printInorder(node.left);
        System.out.print(node.data + " ");
        printInorder(node.right);
    }
  
    /* Driver program to test the above functions */
    public static void main(String args[])
    {
        /* Constructed binary tree is
              1
            /   \
           2     3
         /  \
        4    5
        */
        BinaryTree tree = new BinaryTree();
        tree.root = new Node(1);
        tree.root.left = new Node(2);
        tree.root.right = new Node(3);
        tree.root.left.left = new Node(4);
        tree.root.left.right = new Node(5);
  
        System.out.println("Original tree is : ");
        tree.printInorder(tree.root);
        tree.doubleTree(tree.root);
        System.out.println("");
        System.out.println("Inorder traversal of double tree is : ");
        tree.printInorder(tree.root);
    }
}
 
// This code has been contributed by Mayank Jaiswal(mayank_24)
Python3



# Python3 program to convert
# binary tree to double tree
 
#  A binary tree node has data,
# pointer to left child and a
# pointer to right child
class Node:
    def __init__(self, d):
        self.data = d
        self.left = None
        self.right = None
 
    # Function to convert a tree to var tree
def doubleTree(node) :
    if node == None :
            return
   
    # do the subtrees
    doubleTree(node.left)
    doubleTree(node.right)
   
    # duplicate this node to its left
    oldleft = node.left
    node.left =  Node(node.data)
    node.left.left = oldleft
    
    # Given a binary tree, print its nodes in inorder
def printInorder(node) :
     
    if node == None :
            return
    printInorder(node.left)
    print(node.data,end=' ')
    printInorder(node.right)
     
# Driver Code
if __name__ == '__main__':
     
    '''
    Driver program to test the above functions */
  
        /* Constructed binary tree is
              1
            /   \
           2     3
         /  \
        4    5
    '''
     
    root = Node(1)
    root.left = Node(2)
    root.right = Node(3)
    root.left.left = Node(4)
    root.left.right = Node(5)
    print("Original tree is : ")
    printInorder(root)
    doubleTree(root)
    print()
    print("Inorder traversal of double tree is : ")
    printInorder(root)  
 
    # This code is contributed by jana_sayantan.
C#



// C# program to convert binary tree
// to double tree
 
/* A binary tree node has data,
pointer to left child and
a pointer to right child */
using System;
 
class Node
{
    public int data;
    public Node left, right;
 
    public Node(int item)
    {
        data = item;
        left = right = null;
    }
}
 
public class BinaryTree
{
    Node root;
 
    /* Function to convert a tree to double tree */
    void doubleTree(Node node)
    {
        Node oldleft;
 
        if (node == null)
            return;
 
        /* do the subtrees */
        doubleTree(node.left);
        doubleTree(node.right);
 
        /* duplicate this node to its left */
        oldleft = node.left;
        node.left = new Node(node.data);
        node.left.left = oldleft;
    }
 
    /* Given a binary tree, print its nodes in inorder*/
    void printInorder(Node node)
    {
        if (node == null)
            return;
        printInorder(node.left);
        Console.Write(node.data + " ");
        printInorder(node.right);
    }
 
    // Driver Code
    public static void Main(String []args)
    {
        /* Constructed binary tree is
            1
            / \
        2     3
        / \
        4 5
        */
        BinaryTree tree = new BinaryTree();
        tree.root = new Node(1);
        tree.root.left = new Node(2);
        tree.root.right = new Node(3);
        tree.root.left.left = new Node(4);
        tree.root.left.right = new Node(5);
 
        Console.WriteLine("Original tree is : ");
        tree.printInorder(tree.root);
        tree.doubleTree(tree.root);
        Console.WriteLine("");
        Console.WriteLine("Inorder traversal of " +
                              "double tree is : ");
        tree.printInorder(tree.root);
    }
}
 
// This code is contributed by Rajput-Ji
Javascript



<script>
 
// JavaScript program to convert binary tree to var tree
  
/* A binary tree node has data, pointer to left child
   and a pointer to right child */
 class Node {
        constructor(val) {
            this.data = val;
            this.left = null;
            this.right = null;
        }
    }
 var root;
  
    /* Function to convert a tree to var tree */
    function doubleTree(node)
    {
        var oldleft;
  
        if (node == null)
            return;
  
        /* do the subtrees */
        doubleTree(node.left);
        doubleTree(node.right);
  
        /* duplicate this node to its left */
        oldleft = node.left;
        node.left = new Node(node.data);
        node.left.left = oldleft;
    }
  
    /* Given a binary tree, print its nodes in inorder*/
    function printInorder(node)
    {
        if (node == null)
            return;
        printInorder(node.left);
        document.write(node.data + " ");
        printInorder(node.right);
    }
  
    /* Driver program to test the above functions */
 
        /* Constructed binary tree is
              1
            /   \
           2     3
         /  \
        4    5
        */
        root = new Node(1);
        root.left = new Node(2);
        root.right = new Node(3);
        root.left.left = new Node(4);
        root.left.right = new Node(5);
  
        document.write("Original tree is :<br/> ");
        printInorder(root);
        doubleTree(root);
        document.write("<br/>");
        document.write("Inorder traversal of double tree is : <br/>");
        printInorder(root);
 
// This code is contributed by todaysgaurav
 
</script>
Output
Inorder traversal of the original tree is 
4 2 5 1 3 
Inorder traversal of the double tree is 
4 4 2 2 5 5 1 1 3 3 
Time Complexity: O(n) where n is the number of nodes in the tree.
Auxiliary Space: O(log(n))
Iterative approach:
The idea is to use a stack to iteratively traverse the binary tree in a depth-first manner. For each node encountered during the traversal, a new node is created as a duplicate of the current node, and the original left child of the current node is set as the left child of the new node. The new node is then set as the left child of the current node. This results in a binary tree that is a double tree of the original tree.
Follow the below steps to implement the above idea:
  • If the given root is None, return.
  • Create an empty stack and push the root onto the stack.
  • While the stack is not empty, do the following:
    a. Pop the top node from the stack.
    b. If the node has a right child, push the right child onto the stack.
    c. If the node has a left child, push the left child onto the stack.
    d. Create a duplicate node of the current node and set it as the left child of the current node.
    e. Set the original left child of the current node as the left child of the duplicate node.
  • The tree is now converted to its double tree.
Below is the implementation of the above approach:
C++



#include <bits/stdc++.h>
using namespace std;
 
// Define a class for a binary tree node with data, left,
// and right child pointers
class Node {
  public:
  int data;
  Node* left;
  Node* right;
  Node(int data)
  {
    this->data = data;
    left = right = NULL;
  }
};
 
// Define a function to convert a binary tree to its double
// tree
void doubleTree(Node* root)
{
  // If the root is NULL, return immediately
  if (!root) {
    return;
  }
 
  // Create an empty stack and push the root node onto it
  stack<Node*> s;
  s.push(root);
 
  // Traverse the tree using the stack until it is empty
  while (!s.empty()) {
    // Pop the top node from the stack
    Node* node = s.top();
    s.pop();
 
    // If the node has a right child, push it onto the
    // stack
    if (node->right) {
      s.push(node->right);
    }
 
    // If the node has a left child, push it onto the
    // stack
    if (node->left) {
      s.push(node->left);
    }
 
    // Create a duplicate node of the current node and
    // set it as the left child of the current node
    Node* old_left = node->left;
    node->left = new Node(node->data);
 
    // Set the original left child of the current node
    // as the left child of the duplicate node
    node->left->left = old_left;
  }
}
 
// Define a function to print the inorder traversal of a
// binary tree
void printInorder(Node* root)
{
  if (!root) {
    return;
  }
  printInorder(root->left);
  cout << root->data << " ";
  printInorder(root->right);
}
 
// Driver program to test the above functions
int main()
{
  // Construct a binary tree
  Node* root = new Node(1);
  root->left = new Node(2);
  root->right = new Node(3);
  root->left->left = new Node(4);
  root->left->right = new Node(5);
 
  // Print the original tree
  cout << "Original tree is : " << endl;
  printInorder(root);
  cout << endl;
 
  // Convert the binary tree to its double tree
  doubleTree(root);
 
  // Print the inorder traversal of the double tree
  cout << "Inorder traversal of double tree is : "
    << endl;
  printInorder(root);
 
  return 0;
}
Java



// Java code addition
 
import java.util.Stack;
 
// Define a class for a binary tree node with data, left,
// and right child pointers
class Node {
    public int data;
    public Node left;
    public Node right;
   
    public Node(int data) {
        this.data = data;
        left = right = null;
    }
}
 
// Define a function to convert a binary tree to its double
// tree
class GFG{
    public static void doubleTree(Node root) {
        // If the root is null, return immediately
        if (root == null) {
            return;
        }
 
        // Create an empty stack and push the root node onto it
        Stack<Node> s = new Stack<Node>();
        s.push(root);
 
        // Traverse the tree using the stack until it is empty
        while (!s.empty()) {
            // Pop the top node from the stack
            Node node = s.pop();
 
            // If the node has a right child, push it onto the stack
            if (node.right != null) {
                s.push(node.right);
            }
 
            // If the node has a left child, push it onto the stack
            if (node.left != null) {
                s.push(node.left);
            }
 
            // Create a duplicate node of the current node and set it as
            // the left child of the current node
            Node old_left = node.left;
            node.left = new Node(node.data);
 
            // Set the original left child of the current node as the left
            // child of the duplicate node
            node.left.left = old_left;
        }
    }
 
    // Define a function to print the inorder traversal of a binary tree
    public static void printInorder(Node root) {
        if (root == null) {
            return;
        }
        printInorder(root.left);
        System.out.print(root.data + " ");
        printInorder(root.right);
    }
 
    // Driver program to test the above functions
    public static void main(String[] args) {
        // Construct a binary tree
        Node root = new Node(1);
        root.left = new Node(2);
        root.right = new Node(3);
        root.left.left = new Node(4);
        root.left.right = new Node(5);
 
        // Print the original tree
        System.out.println("Original tree is : ");
        printInorder(root);
        System.out.println();
 
        // Convert the binary tree to its double tree
        doubleTree(root);
 
        // Print the inorder traversal of the double tree
        System.out.println("Inorder traversal of double tree is : ");
        printInorder(root);
    }  
}
 
// The code is contributed by Arushi Goel.
Python3



# Define a class for a binary tree node with data, left, and right child pointers
class Node:
    def __init__(self, data):
        self.data = data
        self.left = None
        self.right = None
 
# Define a function to convert a binary tree to its double tree
def doubleTree(root):
    # If the root is None, return immediately
    if not root:
        return
     
    # Create an empty stack and push the root node onto it
    stack = [root]
     
    # Traverse the tree using the stack until it is empty
    while stack:
        # Pop the top node from the stack
        node = stack.pop()
         
        # If the node has a right child, push it onto the stack
        if node.right:
            stack.append(node.right)
         
        # If the node has a left child, push it onto the stack
        if node.left:
            stack.append(node.left)
         
        # Create a duplicate node of the current node and set it as the left child of the current node
        old_left = node.left
        node.left = Node(node.data)
         
        # Set the original left child of the current node as the left child of the duplicate node
        node.left.left = old_left
 
# Define a function to print the inorder traversal of a binary tree
def printInorder(root):
    if not root:
        return
    printInorder(root.left)
    print(root.data, end=' ')
    printInorder(root.right)
 
# Driver program to test the above functions
if __name__ == '__main__':
    # Construct a binary tree
    root = Node(1)
    root.left = Node(2)
    root.right = Node(3)
    root.left.left = Node(4)
    root.left.right = Node(5)
     
    # Print the original tree
    print("Original tree is : ")
    printInorder(root)
    print()
     
    # Convert the binary tree to its double tree
    doubleTree(root)
     
    # Print the inorder traversal of the double tree
    print("Inorder traversal of double tree is : ")
    printInorder(root)
Javascript



// Javascript code addition
 
// Define a class for a binary tree node
// with data, left, and right child pointers
class Node {
  constructor(data) {
    this.data = data;
    this.left = null;
    this.right = null;
  }
}
 
// Define a function to convert
// a binary tree to its double tree
function doubleTree(root) {
  // If the root is null, return immediately
  if (!root) {
    return;
  }
 
  // Create an empty stack and push the root node onto it
  const stack = [root];
 
  // Traverse the tree using the stack until it is empty
  while (stack.length > 0) {
    // Pop the top node from the stack
    const node = stack.pop();
 
    // If the node has a right child, push it onto the stack
    if (node.right) {
      stack.push(node.right);
    }
 
    // If the node has a left child, push it onto the stack
    if (node.left) {
      stack.push(node.left);
    }
 
    // Create a duplicate node of the current node
    // and set it as the left child of the current node
    const oldLeft = node.left;
    node.left = new Node(node.data);
 
    // Set the original left child of the current node
    // as the left child of the duplicate node
    node.left.left = oldLeft;
  }
}
 
// Define a function to print the inorder traversal of a binary tree
function printInorder(root) {
  if (!root) {
    return;
  }
  printInorder(root.left);
  process.stdout.write(root.data + " ");
  printInorder(root.right);
}
 
// Driver program to test the above functions
if (require.main === module) {
  // Construct a binary tree
  const root = new Node(1);
  root.left = new Node(2);
  root.right = new Node(3);
  root.left.left = new Node(4);
  root.left.right = new Node(5);
 
  // Print the original tree
  console.log("Original tree is : ");
  printInorder(root);
  console.log();
 
  // Convert the binary tree to its double tree
  doubleTree(root);
 
  // Print the inorder traversal of the double tree
  console.log("Inorder traversal of double tree is : ");
  printInorder(root);
}
 
// The code is contributed by Arushi Goel.
Output
Original tree is : 
4 2 5 1 3 
Inorder traversal of double tree is : 
4 4 2 2 5 5 1 1 3 3 
Time Complexity: O(n), where n is the number of nodes in the tree
Auxiliary Space:  O(h), where h is the height of the tree
Please write comments if you find any bug in above code/algorithm, or find other ways to solve the same problem.

My Personal Notes
arrow_drop_up
Last Updated :
20 Apr, 2023
Like Article

Save Article

Similar Reads
1.
Double Order Traversal of a Binary Tree
2.
Double Threaded Binary Search Tree
3.
Complexity of different operations in Binary tree, Binary Search Tree and AVL tree
4.
Maximum sub-tree sum in a Binary Tree such that the sub-tree is also a BST
5.
Convert a Generic Tree(N-array Tree) to Binary Tree
6.
Double factorial
7.
Double Base Palindrome
8.
Print symmetric double triangle pattern
9.
Double the first element and move zero to end
10.
Program to print double headed arrow pattern
Related Tutorials
1.
Learn Data Structures with Javascript | DSA Tutorial
2.
Introduction to Max-Heap – Data Structure and Algorithm Tutorials
3.
Introduction to Set – Data Structure and Algorithm Tutorials
4.
Introduction to Map – Data Structure and Algorithm Tutorials
5.
What is Dijkstra’s Algorithm? | Introduction to Dijkstra's Shortest Path Algorithm
Previous
Amazon Interview | Set 14
Next

Maximum width of a Binary Tree
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
GeeksforGeeks
Vote for difficulty
Current difficulty :
Easy





Improved By :
Article Tags :
Practice Tags :
Report Issue 
We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox