# Print Binary Tree in 2-Dimensions

• Difficulty Level : Medium
• Last Updated : 14 Dec, 2021

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`

## Javascript

 ``

Output:

```                              15

7

14

3

13

6

12

1

11

5

10

2

9

4

8```

Another solution using level order traversal:

## Java

 `import` `java.util.LinkedList;` `public` `class` `Tree1 {` `    ``public` `static` `void` `main(String[] args) {` `        ``Tree1.Node root = ``new` `Tree1.Node(``1``);``        ``Tree1.Node temp = ``null``;``        ``temp = ``new` `Tree1.Node(``2``);``        ``root.left=temp;``        ``temp = ``new` `Tree1.Node(``3``);``        ``root.right=temp;` `        ``temp = ``new` `Tree1.Node(``4``);``        ``root.left.left = temp;``        ``temp=``new` `Tree1.Node(``5``);``        ``root.left.right =temp;``        ``temp=``new` `Tree1.Node(``6``);``        ``root.right.left =temp;``        ``temp=``new` `Tree1.Node(``7``);``        ``root.right.right = temp;` `        ``temp = ``new` `Tree1.Node(``8``);``        ``root.left.left.left = temp;``        ``temp = ``new` `Tree1.Node(``9``);``        ``root.left.left.right = temp;``        ``temp=``new` `Tree1.Node(``10``);``        ``root.left.right.left = temp;``        ``temp=``new` `Tree1.Node(``11``);``        ``root.left.right.right = temp;``        ``temp=``new` `Tree1.Node(``12``);``        ``root.right.left.left = temp;``        ``temp=``new` `Tree1.Node(``13``);``        ``root.right.left.right = temp;``        ``temp=``new` `Tree1.Node(``14``);``        ``root.right.right.left = temp;``        ``temp=``new` `Tree1.Node(``15``);``        ``root.right.right.right = temp;` `        ``printBinaryTree(root);` `    ``}` `public` `static` `class` `Node{` `    ``public` `Node(``int` `data){``        ``this``.data = data;``    ``}``    ``int` `data;``    ``Node left;``    ``Node right;``}` `    ``public` `static` `void` `printBinaryTree(Node root) {``        ``LinkedList treeLevel = ``new` `LinkedList();``        ``treeLevel.add(root);``        ``LinkedList temp = ``new` `LinkedList();``        ``int` `counter = ``0``;``        ``int` `height = heightOfTree(root)-``1``;``        ``//System.out.println(height);``        ``double` `numberOfElements = (Math.pow(``2` `, (height + ``1``)) - ``1``);``        ``//System.out.println(numberOfElements);``        ``while` `(counter <= height) {``            ``Node removed = treeLevel.removeFirst();``            ``if` `(temp.isEmpty()) {``                ``printSpace(numberOfElements / Math.pow(``2` `, counter + ``1``), removed);``            ``} ``else` `{``                ``printSpace(numberOfElements / Math.pow(``2` `, counter), removed);``            ``}``            ``if` `(removed == ``null``) {``                ``temp.add(``null``);``                ``temp.add(``null``);``            ``} ``else` `{``                ``temp.add(removed.left);``                ``temp.add(removed.right);``            ``}` `            ``if` `(treeLevel.isEmpty()) {``                ``System.out.println(``""``);``                ``System.out.println(``""``);``                ``treeLevel = temp;``                ``temp = ``new` `LinkedList<>();``                ``counter++;``            ``}` `        ``}``    ``}` `public` `static` `void` `printSpace(``double` `n, Node removed){``    ``for``(;n>``0``;n--) {``            ``System.out.print(``"\t"``);``    ``}``    ``if``(removed == ``null``){``        ``System.out.print(``" "``);``    ``}``    ``else` `{``        ``System.out.print(removed.data);``    ``}``}` `public` `static` `int` `heightOfTree(Node root){``    ``if``(root==``null``){``        ``return` `0``;``    ``}``     ``return` `1``+ Math.max(heightOfTree(root.left),heightOfTree(root.right));``}` `}`
Output
```                                1

2                                3

4                5                6                7

8        9        10        11        12        13        14        15```

Output: