# Print Binary Tree in 2-Dimensions

• Difficulty Level : Medium
• Last Updated : 29 Jan, 2023

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 << endl;``    ``for` `(``int` `i = COUNT; i < space; i++)``        ``cout << ``" "``;``    ``cout << root->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``        ``= (``struct` `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```

Using preorder Traversal

## Python3

 `class` `Treenode:``    ``def` `__init__(``self``, data):``        ``self``.data ``=` `data``        ``self``.left ``=` `None``        ``self``.right ``=` `None`  `class` `Tree:``    ``def` `__init__(``self``):``        ``self``.root ``=` `None`  `def` `height(root):``    ``if` `root ``is` `None``:``        ``return` `0``    ``return` `max``(height(root.left), height(root.right))``+``1`  `def` `getcol(h):``    ``if` `h ``=``=` `1``:``        ``return` `1``    ``return` `getcol(h``-``1``) ``+` `getcol(h``-``1``) ``+` `1`  `def` `printTree(M, root, col, row, height):``    ``if` `root ``is` `None``:``        ``return``    ``M[row][col] ``=` `root.data``    ``printTree(M, root.left, col``-``pow``(``2``, height``-``2``), row``+``1``, height``-``1``)``    ``printTree(M, root.right, col``+``pow``(``2``, height``-``2``), row``+``1``, height``-``1``)`  `def` `TreePrinter():``    ``h ``=` `height(myTree.root)``    ``col ``=` `getcol(h)``    ``M ``=` `[[``0` `for` `_ ``in` `range``(col)] ``for` `__ ``in` `range``(h)]``    ``printTree(M, myTree.root, col``/``/``2``, ``0``, h)``    ``for` `i ``in` `M:``        ``for` `j ``in` `i:``            ``if` `j ``=``=` `0``:``                ``print``(``" "``, end``=``" "``)``            ``else``:``                ``print``(j, end``=``" "``)``        ``print``("")`  `myTree ``=` `Tree()``myTree.root ``=` `Treenode(``1``)``myTree.root.left ``=` `Treenode(``2``)``myTree.root.right ``=` `Treenode(``3``)``myTree.root.left.left ``=` `Treenode(``4``)``myTree.root.left.right ``=` `Treenode(``5``)``myTree.root.right.left ``=` `Treenode(``6``)``myTree.root.right.right ``=` `Treenode(``7``)``TreePrinter()` `##This Code is By Sudhanshu Nand Kumar`

## C++

 `//C++ code for the above approach``#include ``using` `namespace` `std;` `class` `Treenode {``public``:``    ``int` `data;``    ``Treenode *left, *right;``    ``Treenode(``int` `data) {``        ``this``->data = data;``        ``left = right = NULL;``    ``}``};` `class` `Tree {``public``:``    ``Treenode *root;``    ``Tree() {``        ``root = NULL;``    ``}``};` `int` `height(Treenode *root) {``    ``if` `(root == NULL)``        ``return` `0;``    ``return` `max(height(root->left), height(root->right)) + 1;``}` `int` `getcol(``int` `h) {``    ``if` `(h == 1)``        ``return` `1;``    ``return` `getcol(h - 1) + getcol(h - 1) + 1;``}` `void` `printTree(``int` `**M, Treenode *root, ``int` `col, ``int` `row, ``int` `height) {``    ``if` `(root == NULL)``        ``return``;``    ``M[row][col] = root->data;``    ``printTree(M, root->left, col - ``pow``(2, height - 2), row + 1, height - 1);``    ``printTree(M, root->right, col + ``pow``(2, height - 2), row + 1, height - 1);``}` `void` `TreePrinter(Tree tree) {``    ``int` `h = height(tree.root);``    ``int` `col = getcol(h);``    ``int` `**M = ``new` `int``*[h];``    ``for` `(``int` `i = 0; i < h; i++) {``        ``M[i] = ``new` `int``[col];``    ``}``    ``printTree(M, tree.root, col / 2, 0, h);``    ``for` `(``int` `i = 0; i < h; i++) {``        ``for` `(``int` `j = 0; j < col; j++) {``            ``if` `(M[i][j] == 0)``                ``cout << ``" "` `<< ``" "``;``            ``else``                ``cout << M[i][j] << ``" "``;``        ``}``        ``cout << endl;``    ``}``}` `int` `main() {``    ``Tree myTree;``    ``myTree.root = ``new` `Treenode(1);``    ``myTree.root->left = ``new` `Treenode(2);``    ``myTree.root->right = ``new` `Treenode(3);``    ``myTree.root->left->left = ``new` `Treenode(4);``    ``myTree.root->left->right = ``new` `Treenode(5);``    ``myTree.root->right->left = ``new` `Treenode(6);``    ``myTree.root->right->right = ``new` `Treenode(7);``    ``TreePrinter(myTree);``    ``return` `0;``}`

Output

```      1
2       3
4   5   6   7 ```

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```

This article is contributed by Aditya Goel. If you like GeeksforGeeks and would like to contribute, you can also write an article and mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

My Personal Notes arrow_drop_up