# Double Order Traversal of a Binary Tree

• Last Updated : 11 Oct, 2021

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++

 `// C++ Program to implement``// the above approach``#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* Node = ``new` `node();``    ``Node->data = ch;``    ``Node->left = NULL;``    ``Node->right = NULL;``    ``return` `Node;``}` `// 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

 `// Java program to implement``// the above approach``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

 `# Python3 program to implement``# the above approach` `# 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#

 `// C# program to implement``// the above approach``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`

## Javascript

 ``

Output:

`1 7 4 4 7 5 5 1 3 3 6 6`

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

My Personal Notes arrow_drop_up