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: 
 

Below is the implementation of the above approach:
 



filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ Program to implement
// the above appraoch
#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* 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;
}
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

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

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

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

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 :