# Print Binary Tree in 2-Dimensions

Given a Binary Tree, print it in two dimension.

Examples:

```Input : Pointer to root of below tree
1
/  \
2    3
/ \   / \
4   5  6  7

Output :
7

3

6

1

5

2

4
```

We strongly recommend you to minimize your browser and try this yourself first.

If we take a closer look at the pattern, we can notice following.
1) Rightmost node is printed in first line and leftmost node is printed in last line.
2) Space count increases by a fixed amount at every level.

So we do a reverse inorder traversal (right – root – left) and print tree nodes. We increase space by a fixed amount at every level.

Below is the implementation.

## C++

 `// C++ Program to print binary tree in 2D  ` `#include  ` ` `  `using` `namespace` `std;  ` `#define COUNT 10  ` ` `  `// A binary tree node  ` `class` `Node  ` `{  ` `    ``public``: ` `    ``int` `data;  ` `    ``Node* left, *right;  ` `     `  `    ``/* Constructor that allocates a new node with the  ` `    ``given data and NULL left and right pointers. */` `    ``Node(``int` `data){ ` `        ``this``->data = data; ` `        ``this``->left = NULL; ` `        ``this``->right = NULL; ` `    ``} ` `};  ` ` `  `// Function to print binary tree in 2D  ` `// It does reverse inorder traversal  ` `void` `print2DUtil(Node *root, ``int` `space)  ` `{  ` `    ``// Base case  ` `    ``if` `(root == NULL)  ` `        ``return``;  ` ` `  `    ``// Increase distance between levels  ` `    ``space += COUNT;  ` ` `  `    ``// Process right child first  ` `    ``print2DUtil(root->right, space);  ` ` `  `    ``// Print current node after space  ` `    ``// count  ` `    ``cout<data<<``"\n"``;  ` ` `  `    ``// Process left child  ` `    ``print2DUtil(root->left, space);  ` `}  ` ` `  `// Wrapper over print2DUtil()  ` `void` `print2D(Node *root)  ` `{  ` `    ``// Pass initial space count as 0  ` `    ``print2DUtil(root, 0);  ` `}  ` ` `  `// Driver code  ` `int` `main()  ` `{  ` `    ``Node *root = ``new` `Node(1);  ` `    ``root->left = ``new` `Node(2);  ` `    ``root->right = ``new` `Node(3);  ` ` `  `    ``root->left->left = ``new` `Node(4);  ` `    ``root->left->right = ``new` `Node(5);  ` `    ``root->right->left = ``new` `Node(6);  ` `    ``root->right->right = ``new` `Node(7);  ` ` `  `    ``root->left->left->left = ``new` `Node(8);  ` `    ``root->left->left->right = ``new` `Node(9);  ` `    ``root->left->right->left = ``new` `Node(10);  ` `    ``root->left->right->right = ``new` `Node(11);  ` `    ``root->right->left->left = ``new` `Node(12);  ` `    ``root->right->left->right = ``new` `Node(13);  ` `    ``root->right->right->left = ``new` `Node(14);  ` `    ``root->right->right->right = ``new` `Node(15);  ` `     `  `    ``print2D(root);  ` ` `  `    ``return` `0;  ` `}  ` ` `  `// This code is contributed by rathbhupendra `

## C

 `// Program to print binary tree in 2D ` `#include ` `#include ` `#define COUNT 10 ` ` `  `// A binary tree node ` `struct` `Node ` `{ ` `    ``int` `data; ` `    ``struct` `Node* left, *right; ` `}; ` ` `  `// Helper function to allocates a new node ` `struct` `Node* newNode(``int` `data) ` `{ ` `    ``struct` `Node* node = ``malloc``(``sizeof``(``struct` `Node)); ` `    ``node->data = data; ` `    ``node->left = node->right = NULL; ` `    ``return` `node; ` `} ` ` `  `// Function to print binary tree in 2D ` `// It does reverse inorder traversal ` `void` `print2DUtil(``struct` `Node *root, ``int` `space) ` `{ ` `    ``// Base case ` `    ``if` `(root == NULL) ` `        ``return``; ` ` `  `    ``// Increase distance between levels ` `    ``space += COUNT; ` ` `  `    ``// Process right child first ` `    ``print2DUtil(root->right, space); ` ` `  `    ``// Print current node after space ` `    ``// count ` `    ``printf``(``"\n"``); ` `    ``for` `(``int` `i = COUNT; i < space; i++) ` `        ``printf``(``" "``); ` `    ``printf``(``"%d\n"``, root->data); ` ` `  `    ``// Process left child ` `    ``print2DUtil(root->left, space); ` `} ` ` `  `// Wrapper over print2DUtil() ` `void` `print2D(``struct` `Node *root) ` `{ ` `   ``// Pass initial space count as 0 ` `   ``print2DUtil(root, 0); ` `} ` ` `  `// Driver program to test above functions ` `int` `main() ` `{  ` `    ``struct` `Node *root   = newNode(1); ` `    ``root->left   = newNode(2); ` `    ``root->right  = newNode(3); ` ` `  `    ``root->left->left  = newNode(4); ` `    ``root->left->right = newNode(5); ` `    ``root->right->left  = newNode(6); ` `    ``root->right->right = newNode(7); ` ` `  `    ``root->left->left->left  = newNode(8); ` `    ``root->left->left->right  = newNode(9); ` `    ``root->left->right->left  = newNode(10); ` `    ``root->left->right->right  = newNode(11); ` `    ``root->right->left->left  = newNode(12); ` `    ``root->right->left->right  = newNode(13); ` `    ``root->right->right->left  = newNode(14); ` `    ``root->right->right->right  = newNode(15);  ` `     `  `    ``print2D(root); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java Program to print binary tree in 2D  ` `class` `GFG ` `{ ` `     `  `static` `final` `int` `COUNT = ``10``;  ` ` `  `// A binary tree node  ` `static` `class` `Node  ` `{  ` `    ``int` `data;  ` `    ``Node left, right;  ` `     `  `    ``/* Constructor that allocates a new node with the  ` `    ``given data and null left and right pointers. */` `    ``Node(``int` `data) ` `    ``{  ` `        ``this``.data = data;  ` `        ``this``.left = ``null``;  ` `        ``this``.right = ``null``;  ` `    ``}  ` `};  ` ` `  `// Function to print binary tree in 2D  ` `// It does reverse inorder traversal  ` `static` `void` `print2DUtil(Node root, ``int` `space)  ` `{  ` `    ``// Base case  ` `    ``if` `(root == ``null``)  ` `        ``return``;  ` ` `  `    ``// Increase distance between levels  ` `    ``space += COUNT;  ` ` `  `    ``// Process right child first  ` `    ``print2DUtil(root.right, space);  ` ` `  `    ``// Print current node after space  ` `    ``// count  ` `    ``System.out.print(``"\n"``);  ` `    ``for` `(``int` `i = COUNT; i < space; i++)  ` `        ``System.out.print(``" "``);  ` `    ``System.out.print(root.data + ``"\n"``);  ` ` `  `    ``// Process left child  ` `    ``print2DUtil(root.left, space);  ` `}  ` ` `  `// Wrapper over print2DUtil()  ` `static` `void` `print2D(Node root)  ` `{  ` `    ``// Pass initial space count as 0  ` `    ``print2DUtil(root, ``0``);  ` `}  ` ` `  `// Driver code  ` `public` `static` `void` `main(String args[])  ` `{  ` `    ``Node root = ``new` `Node(``1``);  ` `    ``root.left = ``new` `Node(``2``);  ` `    ``root.right = ``new` `Node(``3``);  ` ` `  `    ``root.left.left = ``new` `Node(``4``);  ` `    ``root.left.right = ``new` `Node(``5``);  ` `    ``root.right.left = ``new` `Node(``6``);  ` `    ``root.right.right = ``new` `Node(``7``);  ` ` `  `    ``root.left.left.left = ``new` `Node(``8``);  ` `    ``root.left.left.right = ``new` `Node(``9``);  ` `    ``root.left.right.left = ``new` `Node(``10``);  ` `    ``root.left.right.right = ``new` `Node(``11``);  ` `    ``root.right.left.left = ``new` `Node(``12``);  ` `    ``root.right.left.right = ``new` `Node(``13``);  ` `    ``root.right.right.left = ``new` `Node(``14``);  ` `    ``root.right.right.right = ``new` `Node(``15``);  ` `     `  `    ``print2D(root);  ` `}  ` `} ` ` `  `// This code is contributed by Arnab Kundu `

## Python3

 `# Python3 Program to print binary tree in 2D  ` `COUNT ``=` `[``10``]  ` ` `  `# Binary Tree Node  ` `""" utility that allocates a newNode  ` `with the given key """` `class` `newNode:  ` ` `  `    ``# Construct to create a newNode  ` `    ``def` `__init__(``self``, key):  ` `        ``self``.data ``=` `key ` `        ``self``.left ``=` `None` `        ``self``.right ``=` `None` ` `  `# Function to print binary tree in 2D  ` `# It does reverse inorder traversal  ` `def` `print2DUtil(root, space) : ` ` `  `    ``# Base case  ` `    ``if` `(root ``=``=` `None``) : ` `        ``return` ` `  `    ``# Increase distance between levels  ` `    ``space ``+``=` `COUNT[``0``] ` ` `  `    ``# Process right child first  ` `    ``print2DUtil(root.right, space)  ` ` `  `    ``# Print current node after space  ` `    ``# count  ` `    ``print``()  ` `    ``for` `i ``in` `range``(COUNT[``0``], space): ` `        ``print``(end ``=` `" "``)  ` `    ``print``(root.data)  ` ` `  `    ``# Process left child  ` `    ``print2DUtil(root.left, space)  ` ` `  `# Wrapper over print2DUtil()  ` `def` `print2D(root) : ` `     `  `    ``# space=[0] ` `    ``# Pass initial space count as 0  ` `    ``print2DUtil(root, ``0``)  ` ` `  `# Driver Code  ` `if` `__name__ ``=``=` `'__main__'``: ` ` `  `    ``root ``=` `newNode(``1``)  ` `    ``root.left ``=` `newNode(``2``)  ` `    ``root.right ``=` `newNode(``3``)  ` ` `  `    ``root.left.left ``=` `newNode(``4``)  ` `    ``root.left.right ``=` `newNode(``5``)  ` `    ``root.right.left ``=` `newNode(``6``)  ` `    ``root.right.right ``=` `newNode(``7``)  ` ` `  `    ``root.left.left.left ``=` `newNode(``8``)  ` `    ``root.left.left.right ``=` `newNode(``9``)  ` `    ``root.left.right.left ``=` `newNode(``10``)  ` `    ``root.left.right.right ``=` `newNode(``11``)  ` `    ``root.right.left.left ``=` `newNode(``12``)  ` `    ``root.right.left.right ``=` `newNode(``13``)  ` `    ``root.right.right.left ``=` `newNode(``14``)  ` `    ``root.right.right.right ``=` `newNode(``15``)  ` `     `  `    ``print2D(root) ` ` `  `# This code is contributed by ` `# Shubham Singh(SHUBHAMSINGH10) `

## C#

 `// C# Program to print binary tree in 2D  ` `using` `System; ` ` `  `class` `GFG  ` `{  ` `     `  `static` `readonly` `int` `COUNT = 10;  ` ` `  `// A binary tree node  ` `public` `class` `Node  ` `{  ` `    ``public` `int` `data;  ` `    ``public` `Node left, right;  ` `     `  `    ``/* Constructor that allocates a new node with the  ` `    ``given data and null left and right pointers. */` `    ``public` `Node(``int` `data)  ` `    ``{  ` `        ``this``.data = data;  ` `        ``this``.left = ``null``;  ` `        ``this``.right = ``null``;  ` `    ``}  ` `};  ` ` `  `// Function to print binary tree in 2D  ` `// It does reverse inorder traversal  ` `static` `void` `print2DUtil(Node root, ``int` `space)  ` `{  ` `    ``// Base case  ` `    ``if` `(root == ``null``)  ` `        ``return``;  ` ` `  `    ``// Increase distance between levels  ` `    ``space += COUNT;  ` ` `  `    ``// Process right child first  ` `    ``print2DUtil(root.right, space);  ` ` `  `    ``// Print current node after space  ` `    ``// count  ` `    ``Console.Write(``"\n"``);  ` `    ``for` `(``int` `i = COUNT; i < space; i++)  ` `        ``Console.Write(``" "``);  ` `    ``Console.Write(root.data + ``"\n"``);  ` ` `  `    ``// Process left child  ` `    ``print2DUtil(root.left, space);  ` `}  ` ` `  `// Wrapper over print2DUtil()  ` `static` `void` `print2D(Node root)  ` `{  ` `    ``// Pass initial space count as 0  ` `    ``print2DUtil(root, 0);  ` `}  ` ` `  `// Driver code  ` `public` `static` `void` `Main(String []args)  ` `{  ` `    ``Node root = ``new` `Node(1);  ` `    ``root.left = ``new` `Node(2);  ` `    ``root.right = ``new` `Node(3);  ` ` `  `    ``root.left.left = ``new` `Node(4);  ` `    ``root.left.right = ``new` `Node(5);  ` `    ``root.right.left = ``new` `Node(6);  ` `    ``root.right.right = ``new` `Node(7);  ` ` `  `    ``root.left.left.left = ``new` `Node(8);  ` `    ``root.left.left.right = ``new` `Node(9);  ` `    ``root.left.right.left = ``new` `Node(10);  ` `    ``root.left.right.right = ``new` `Node(11);  ` `    ``root.right.left.left = ``new` `Node(12);  ` `    ``root.right.left.right = ``new` `Node(13);  ` `    ``root.right.right.left = ``new` `Node(14);  ` `    ``root.right.right.right = ``new` `Node(15);  ` `     `  `    ``print2D(root);  ` `}  ` `}  ` ` `  `// This code is contributed by Princi Singh `

Output :

```
15

7

14

3

13

6

12

1

11

5

10

2

9

4

8
```

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.

My Personal Notes arrow_drop_up

Article Tags :
Practice Tags :

5

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.