# Double Order Traversal of a Binary Tree

Given a Binary Tree consisting of N nodes, the task is to print its Double Order Traversal.

Double Order Traversal is a tree traversal technique in which every node is traversed twice in the following order:

• Visit the Node.
• Traverse the Left Subtree.
• Visit the Node.
• Traverse the Right Subtree.

Examples:

```Input:
1
/   \
7     3
/ \   /
4   5 6
Output: 1 7 4 4 7 5 5 1 3 6 6 3

Input:
1
/   \
7     3
/ \     \
4   5     6
Output: 1 7 4 4 7 5 5 1 3 3 6 6

```

Approach:
The idea is to perform Inorder Traversal recursively on the given Binary Tree and print the node value on visiting a vertex and after the recursive call to the left subtree during the traversal.
Follow the steps below to solve the problem:

• Start Inorder traversal from the root.
• If the current node does not exist, simply return from it.
• Otherwise:
• Print the value of the current node.
• Recursively traverse the left subtree.
• Again, print the current node.
• Recursively traverse the right subtree.
• Repeat the above steps until all nodes in the tree are visited.

Below is the implementation of the above approach:

 `// C++ Program to implement` `// the above appraoch` `#include ` `using` `namespace` `std;`   `// Node Structure` `struct` `node {` `    ``char` `data;` `    ``struct` `node *left, *right;` `};`   `// Function to create new node` `struct` `node* newNode(``char` `ch)` `{` `    ``// Allocate a new node in memory` `    ``struct` `node* n = (``struct` `node*)` `        ``malloc``(``sizeof``(``struct` `node));` `    ``n->data = ch;` `    ``n->left = NULL;` `    ``n->right = NULL;` `    ``return` `n;` `}`   `// Function to print Double Order traversal` `void` `doubleOrderTraversal(``struct` `node* root)` `{` `    ``if` `(!root)` `        ``return``;`   `    ``// Print Node Value` `    ``cout << root->data << ``" "``;`   `    ``// Traverse Left Subtree` `    ``doubleOrderTraversal(root->left);`   `    ``// Print Node Value` `    ``cout << root->data << ``" "``;`   `    ``// Traverse Right SubTree` `    ``doubleOrderTraversal(root->right);` `}`   `// Driver Code` `int` `main()` `{` `    ``struct` `node* root = newNode(``'1'``);` `    ``root->left = newNode(``'7'``);` `    ``root->right = newNode(``'3'``);` `    ``root->left->left = newNode(``'4'``);` `    ``root->left->right = newNode(``'5'``);` `    ``root->right->right = newNode(``'6'``);`   `    ``doubleOrderTraversal(root);` `    ``return` `0;` `}`

 `// Java program to implement` `// the above appraoch` `class` `GFG{`   `// Node Structure` `static` `class` `node ` `{` `    ``char` `data;` `    ``node left, right;` `};`   `// Function to create new node` `static` `node newNode(``char` `ch)` `{` `    `  `    ``// Allocate a new node in memory` `    ``node n = ``new` `node();` `    ``n.data = ch;` `    ``n.left = ``null``;` `    ``n.right = ``null``;` `    ``return` `n;` `}`   `// Function to print Double Order traversal` `static` `void` `doubleOrderTraversal(node root)` `{` `    ``if` `(root == ``null``)` `        ``return``;`   `    ``// Print Node Value` `    ``System.out.print(root.data + ``" "``);`   `    ``// Traverse Left Subtree` `    ``doubleOrderTraversal(root.left);`   `    ``// Print Node Value` `    ``System.out.print(root.data + ``" "``);`   `    ``// Traverse Right SubTree` `    ``doubleOrderTraversal(root.right);` `}`   `// Driver Code` `public` `static` `void` `main(String[] args)` `{` `    ``node root = newNode(``'1'``);` `    ``root.left = newNode(``'7'``);` `    ``root.right = newNode(``'3'``);` `    ``root.left.left = newNode(``'4'``);` `    ``root.left.right = newNode(``'5'``);` `    ``root.right.right = newNode(``'6'``);`   `    ``doubleOrderTraversal(root);` `}` `}`   `// This code is contributed by gauravrajput1 `

 `# Python3 program to implement` `# the above appraoch`   `# Node Structure` `class` `Node:`   `    ``# Initialise new node` `    ``def` `__init__(``self``, ch):` `        `  `        ``self``.data ``=` `ch` `        ``self``.left ``=` `None` `        ``self``.right ``=` `None`   `# Function to print Double Order traversal` `def` `doubleOrderTraveersal(root):` `    `  `    ``if` `not` `root:` `        ``return`   `    ``# Print node value` `    ``print``(root.data, end ``=` `" "``)`   `    ``# Traverse left subtree` `    ``doubleOrderTraveersal(root.left)`   `    ``# Print node value` `    ``print``(root.data, end ``=` `" "``)`   `    ``# Traverse right subtree` `    ``doubleOrderTraveersal(root.right)`   `# Driver code` `if` `__name__ ``=``=` `'__main__'``:`   `    ``root ``=` `Node(``1``)` `    ``root.left ``=` `Node(``7``)` `    ``root.right ``=` `Node(``3``)` `    ``root.left.left ``=` `Node(``4``)` `    ``root.left.right ``=` `Node(``5``)` `    ``root.right.right ``=` `Node(``6``)` `    `  `    ``doubleOrderTraveersal(root)`   `# This code is contributed by Shivam Singh`

 `// C# program to implement` `// the above appraoch` `using` `System;` `class` `GFG{`   `// Node Structure` `class` `node ` `{` `    ``public` `char` `data;` `    ``public` `node left, right;` `};`   `// Function to create new node` `static` `node newNode(``char` `ch)` `{` `    `  `    ``// Allocate a new node in memory` `    ``node n = ``new` `node();` `    ``n.data = ch;` `    ``n.left = ``null``;` `    ``n.right = ``null``;` `    ``return` `n;` `}`   `// Function to print Double Order traversal` `static` `void` `doubleOrderTraversal(node root)` `{` `    ``if` `(root == ``null``)` `        ``return``;`   `    ``// Print Node Value` `    ``Console.Write(root.data + ``" "``);`   `    ``// Traverse Left Subtree` `    ``doubleOrderTraversal(root.left);`   `    ``// Print Node Value` `    ``Console.Write(root.data + ``" "``);`   `    ``// Traverse Right SubTree` `    ``doubleOrderTraversal(root.right);` `}`   `// Driver Code` `public` `static` `void` `Main(String[] args)` `{` `    ``node root = newNode(``'1'``);` `    ``root.left = newNode(``'7'``);` `    ``root.right = newNode(``'3'``);` `    ``root.left.left = newNode(``'4'``);` `    ``root.left.right = newNode(``'5'``);` `    ``root.right.right = newNode(``'6'``);`   `    ``doubleOrderTraversal(root);` `}` `}`   `// This code is contributed by gauravrajput1`

Output:
```1 7 4 4 7 5 5 1 3 3 6 6

```

Time Complexity: O(N)
Auxiliary Space: O(1)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

Check out this Author's contributed articles.

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 Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Improved By : SHIVAMSINGH67, GauravRajput1

Article Tags :