Double Order Traversal of a Binary Tree
Last Updated :
21 Oct, 2024
Given a Binary Tree, the task is to find 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:
Output: 1 7 4 4 7 5 5 1 3 6 6 3
Explanation: The root (1) is visited, followed by its left subtree (7), where nodes 4 and 5 are each visited twice before returning to the root and visiting the right subtree (3), which contains node 6.
Input:
Output: 1 7 4 4 7 5 5 1 3 3 6 6
Explanation: The root (1) is visited, followed by its left subtree (7), where nodes 4 and 5 are each visited twice before returning to the root and visiting the right subtree (3), where node 6 is visited twice.
Approach:
The idea is to perform Inorder Traversal recursively on the given Binary Tree and store 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:
- Store the value of the current node.
- Recursively traverse the left subtree.
- Again, store 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++ implementation for printing double order
// traversal of a Tree
#include <bits/stdc++.h>
using namespace std;
class Node {
public:
int data;
Node* left;
Node* right;
Node(int x) {
data = x;
left = nullptr;
right = nullptr;
}
};
// Function to perform double order traversal
vector<int> doubleOrderTraversal(Node* root) {
vector<int> result;
if (!root) return result;
// Store node value before traversing
// left subtree
result.push_back(root->data);
// Recursively traverse the left subtree
vector<int> leftSubtree
= doubleOrderTraversal(root->left);
result.insert(result.end(),
leftSubtree.begin(), leftSubtree.end());
// Store node value again after
// traversing left subtree
result.push_back(root->data);
// Recursively traverse the right subtree
vector<int> rightSubtree
= doubleOrderTraversal(root->right);
result.insert(result.end(),
rightSubtree.begin(), rightSubtree.end());
return result;
}
int main() {
// Representation of the binary tree
// 1
// / \
// 7 3
// / \ /
// 4 5 6
Node* root = new Node(1);
root->left = new Node(7);
root->right = new Node(3);
root->left->left = new Node(4);
root->left->right = new Node(5);
root->right->left = new Node(6);
vector<int> result
= doubleOrderTraversal(root);
for (int num : result) {
cout << num << " ";
}
return 0;
}
// Java implementation for printing double order
// traversal of a Tree
import java.util.ArrayList;
class Node {
int data;
Node left, right;
Node(int x) {
data = x;
left = null;
right = null;
}
}
class GfG {
// Function to perform double order traversal
static ArrayList<Integer>
doubleOrderTraversal(Node root) {
ArrayList<Integer> result = new ArrayList<>();
if (root == null) return result;
// Store node value before traversing
// left subtree
result.add(root.data);
// Recursively traverse the left subtree
ArrayList<Integer> leftSubtree
= doubleOrderTraversal(root.left);
result.addAll(leftSubtree);
// Store node value again after
// traversing left subtree
result.add(root.data);
// Recursively traverse the right subtree
ArrayList<Integer> rightSubtree
= doubleOrderTraversal(root.right);
result.addAll(rightSubtree);
return result;
}
public static void main(String[] args) {
// Representation of the binary tree
// 1
// / \
// 7 3
// / \ /
// 4 5 6
Node root = new Node(1);
root.left = new Node(7);
root.right = new Node(3);
root.left.left = new Node(4);
root.left.right = new Node(5);
root.right.left = new Node(6);
ArrayList<Integer> result
= doubleOrderTraversal(root);
for (int num : result) {
System.out.print(num + " ");
}
}
}
# Python implementation for printing double order
# traversal of a Tree
class Node:
def __init__(self, x):
self.data = x
self.left = None
self.right = None
# Function to perform double order traversal
def double_order_traversal(root):
result = []
if root is None:
return result
# Store node value before traversing
# left subtree
result.append(root.data)
# Recursively traverse the left subtree
left_subtree = double_order_traversal(root.left)
result.extend(left_subtree)
# Store node value again after
# traversing left subtree
result.append(root.data)
# Recursively traverse the right subtree
right_subtree = double_order_traversal(root.right)
result.extend(right_subtree)
return result
if __name__ == "__main__":
# Representation of the binary tree
# 1
# / \
# 7 3
# / \ /
# 4 5 6
root = Node(1)
root.left = Node(7)
root.right = Node(3)
root.left.left = Node(4)
root.left.right = Node(5)
root.right.left = Node(6)
result = double_order_traversal(root)
print(" ".join(map(str, result)))
// C# implementation for printing double order
// traversal of a Tree
using System;
using System.Collections.Generic;
class Node {
public int data;
public Node left, right;
public Node(int x) {
data = x;
left = null;
right = null;
}
}
class GfG {
// Function to perform double order traversal
static List<int> DoubleOrderTraversal(Node root) {
List<int> result = new List<int>();
if (root == null) return result;
// Store node value before traversing
// left subtree
result.Add(root.data);
// Recursively traverse the left subtree
List<int> leftSubtree
= DoubleOrderTraversal(root.left);
result.AddRange(leftSubtree);
// Store node value again after
// traversing left subtree
result.Add(root.data);
// Recursively traverse the right subtree
List<int> rightSubtree
= DoubleOrderTraversal(root.right);
result.AddRange(rightSubtree);
return result;
}
static void Main(string[] args) {
// Representation of the binary tree
// 1
// / \
// 7 3
// / \ /
// 4 5 6
Node root = new Node(1);
root.left = new Node(7);
root.right = new Node(3);
root.left.left = new Node(4);
root.left.right = new Node(5);
root.right.left = new Node(6);
List<int> result
= DoubleOrderTraversal(root);
foreach (int num in result) {
Console.Write(num + " ");
}
}
}
// JavaScript implementation for printing double order
// traversal of a Tree
class Node {
constructor(x) {
this.data = x;
this.left = null;
this.right = null;
}
}
// Function to perform double order traversal
function doubleOrderTraversal(root) {
const result = [];
if (root === null) return result;
// Store node value before traversing
// left subtree
result.push(root.data);
// Recursively traverse the left subtree
const leftSubtree = doubleOrderTraversal(root.left);
result.push(...leftSubtree);
// Store node value again after
// traversing left subtree
result.push(root.data);
// Recursively traverse the right subtree
const rightSubtree = doubleOrderTraversal(root.right);
result.push(...rightSubtree);
return result;
}
// Representation of the binary tree
// 1
// / \
// 7 3
// / \ /
// 4 5 6
const root = new Node(1);
root.left = new Node(7);
root.right = new Node(3);
root.left.left = new Node(4);
root.left.right = new Node(5);
root.right.left = new Node(6);
const result = doubleOrderTraversal(root);
console.log(result.join(" "));
Output1 7 4 4 7 5 5 1 3 6 6 3
Time complexity: O(n), as each node is visited twice, where n is the number of nodes in the tree.
Auxiliary Space: O(h), due to recursion, where h is the tree's height.
Similar Reads
Middle To Up-Down Order traversal of a Binary Tree Given a binary tree, the task is to traverse this binary tree from the middle to the up-down order. In Middle to up-down order traversal, the following steps are performed: First, print the middle level of the tree.Then, print the elements at one level above the middle level of the tree.Then, print
15+ min read
Preorder Traversal of Binary Tree Preorder traversal is a tree traversal method that follows the Root-Left-Right order:The root node of the subtree is visited first.Next, the left subtree is recursively traversed.Finally, the right subtree is recursively traversed.How does Preorder Traversal work?Key Properties: Used in expression t
5 min read
Triple Order Traversal of a Binary Tree Given a Binary Tree, the task is to find its Triple Order Traversal. Triple Order Traversal is a tree traversal technique in which every node is traversed thrice in the following order: Visit the root nodeTraverse the left subtreeVisit the root nodeTraverse the right subtreeVisit the root node.Examp
7 min read
Inorder Traversal of Binary Tree Inorder traversal is a depth-first traversal method that follows this sequence:Left subtree is visited first.Root node is processed next.Right subtree is visited last.How does Inorder Traversal work?Key Properties:If applied to a Binary Search Tree (BST), it returns elements in sorted order.Ensures
5 min read
Boundary Traversal of binary tree Given a binary tree, the task is to find the boundary nodes of the binary tree Anti-Clockwise starting from the root.The boundary includes:left boundary (nodes on left excluding leaf nodes)leaves (consist of only the leaf nodes)right boundary (nodes on right excluding leaf nodes)The left boundary is
15+ min read