 GFG App
Open App Browser
Continue

# Double Tree

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 ` `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 ` `#include ` ` `  `/* 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

 ``

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 ` `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 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 s = ``new` `Stack();` `        ``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