# Print a two-dimensional view of a Binary Tree

Posted in  Vinay Khatri
Last updated on December 6, 2023

## Problem

Given a binary tree, the task is to print the two-dimensional view of it.

#### Sample Input

```             1
/  \
9    3
/ \   / \
2   5  6  10 ```

#### Sample Output:

```                    10
3
6
1
5
9

2```

## Approach

This problem is based on the observations that we can make from the examples. Below are the observations:

1) Rightmost node of the tree is printed in the first line, and the leftmost node is printed in the last line.

2) Space count increases by a fixed quantity at every level. We need to do a reverse in-order traversal and print tree nodes. We increase space by a fixed amount at every level. The reverse in order will first explore the right subtree, then the root, and then the left subtree.

### Complexity Analysis

The time complexity would be O(N), and the space complexity would also be O(N) due to the call stack.

### C++ Programming

```#include<bits/stdc++.h>
using namespace std;

struct TreeNode
{
int val;
TreeNode *left, *right;

TreeNode(int val)
{
this->val = val;
this->left = this->right = nullptr;
}
};

void inOrder(TreeNode* root, int gap = 0, int height = 10)
{
// Base case
if (!root) {
return;
}

// increase the gap count
gap += height;

// print right child
inOrder(root->right, gap);
cout << endl;

// print the current node after gap
for (int i = height; i < gap; i++) {
cout << ' ';
}

cout << root->val;

// print left child
cout << endl;
inOrder(root->left, gap);
}

int main()
{
TreeNode* root = new TreeNode(1);
root->left = new TreeNode(9);
root->right = new TreeNode(3);
root->left->left = new TreeNode(2);
root->left->right = new TreeNode(5);
root->right->left = new TreeNode(6);
root->right->right = new TreeNode(10);

inOrder(root);

return 0;
}```

#### Output

```                    10
3
6
1
5
9
2
```

### Java Programming

```class TreeNode
{
int val;
TreeNode left, right;

TreeNode(int val)
{
this.val = val;
this.left = this.right = null;
}
}

class Main
{
public static void inOrder(TreeNode root, int gap, int height)
{
// Base case
if (root == null) {
return;
}

// increase the gap
gap += height;

// print right child
inOrder(root.right, gap, height);
System.out.println();

// print the current node after spaces
for (int i = height; i < gap; i++) {
System.out.print(' ');
}

System.out.print(root.val);

// print left child
System.out.println();
inOrder(root.left, gap, height);
}

public static void main(String[] args)
{
TreeNode root = new TreeNode(1);
root.left = new TreeNode(9);
root.right = new TreeNode(3);
root.left.left = new TreeNode(2);
root.left.right = new TreeNode(5);
root.right.left = new TreeNode(6);
root.right.right = new TreeNode(10);

int gap = 0, height = 10;
inOrder(root, gap, height);
}
}```

#### Output

```                    10
3
6
1
5
9
2
```

### Python Programming

```class TreeNode:
def __init__(self, val, left=None, right=None):
self.val = val
self.left = left
self.right = right

def inOrder(root, gap, height):
# Base case
if root is None:
return

# increase the gap
gap += height

# print right child
inOrder(root.right, gap, height)
print()

# print the current node
for i in range(height, gap):
print(' ', end='')

print(root.val, end='')

# print left child
print()
inOrder(root.left, gap, height)

root = TreeNode(1)
root.left = TreeNode(9)
root.right = TreeNode(3)
root.left.left = TreeNode(2)
root.left.right = TreeNode(5)
root.right.left = TreeNode(6)
root.right.right = TreeNode(10)

gap = 0
height = 10
inOrder(root, gap, height)```

#### Output

```                  10
3
6
1
5
9
2```