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 <iostream> 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
<script> // Javascript program to implement // the above approach // Node Structure class node { constructor()
{
this .data = 0;
this .left = null ;
this .right = null ;
}
}; // Function to create new node function newNode(ch)
{ // Allocate a new node in memory
var n = new node();
n.data = ch;
n.left = null ;
n.right = null ;
return n;
} // Function to print Double Order traversal function doubleOrderTraversal(root)
{ if (root == null )
return ;
// Print Node Value
document.write(root.data + " " );
// Traverse Left Subtree
doubleOrderTraversal(root.left);
// Print Node Value
document.write(root.data + " " );
// Traverse Right SubTree
doubleOrderTraversal(root.right);
} // Driver Code var 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); </script> |
Output:
1 7 4 4 7 5 5 1 3 3 6 6
Time Complexity: O(N)
Auxiliary Space: O(1)