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

// 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)