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.
- Rightmost node is printed in first line and leftmost node is printed in last line.
- 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 <bits/stdc++.h> 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 <malloc.h> #include <stdio.h> #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
<script> // JavaScript Program to print binary tree in 2D let COUNT = 10; // A binary tree node class Node { constructor(data) { this .data = data; this .left = null ; this .right = null ; } } // Function to print binary tree in 2D // It does reverse inorder traversal function print2DUtil(root,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 document.write( "<br>" ); for (let i = COUNT; i < space; i++) document.write( "  " ); document.write(root.data + "\n" ); // Process left child print2DUtil(root.left, space); } // Wrapper over print2DUtil() function print2D(root) { // Pass initial space count as 0 print2DUtil(root, 0); } // Driver code let 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 patel2127 </script> |
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 <bits/stdc++.h> 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<Node> treeLevel = new LinkedList<Node>(); treeLevel.add(root); LinkedList<Node> temp = new LinkedList<Node>(); 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.
Please Login to comment...