# Pretty Print a Binary Tree in Python

A Binary Tree is a finite set of elements that is either empty or is partitioned into three disjoint subsets. The first subset contains a single element called root. The other two subsets are themselves binary trees and called as left and right subtrees of original tree. Each element of a binary tree is called a node of the tree.

Consider this Binary tree

Here, 10 is the root node, node 2 is the left child of the root node and node 21 is the right child of the root node and similarly for the rest of the tree.

Visualizing a binary tree can help in understanding its structure and the relationships between its nodes. Let’s write a Python script to pretty print a binary tree in Python using ASCII characters to represent the tree structure.

###### Printing the Binary Tree

To print the binary tree, we need a recursive function that will traverse the tree and print each node in a structured manner. We’ll use ASCII characters to draw the tree branches:

• │ to represent a vertical branch
• └── to represent a left child
• ┌── to represent a right child
###### Pseudocode

The idea here is to do a Depth First Traversal of the Binary tree and determine each node’s position in the tree.

Depth-First Traversal1. First recursively traverse the right subtree,2. Then process the current node,3. And finally traverse the left subtree.Processing the node1. Use a prefix parameter to keeps track of the current indentation level and structure.2. Use is_left parameter to track whether the current node is a left child or right child.3. The current node’s value is printed with the appropriate prefix. If it’s a left child, the prefix includes └──; if it’s a right child, the prefix includes ┌──.This ensures that the tree is printed from top to bottom and right to left.

Depth First Traversal is discussed in detail in this post – DFS (Depth-First Search) in Binary Trees and Graphs

###### Code Implementation
# Class to represent a Tree node
class TreeNode:
def __init__(self, value):
self.value = value
self.left = None
self.right = None

def print_tree(root, prefix="", is_left=True):
if root is not None:
print_tree(root.right, prefix + ("│   " if is_left else "    "), False)
print(prefix + ("└── " if is_left else "┌── ") + str(root.value))
print_tree(root.left, prefix + ("    " if is_left else "│   "), True)

# Example Usage
root = TreeNode(10)
root.left = TreeNode(2)
root.right = TreeNode(21)
root.right.left = TreeNode(15)
root.right.right = TreeNode(31)

print_tree(root)


Output

│       ┌── 31│   ┌── 21│   │   └── 15└── 10    └── 2

Time complexity: O(N), print_tree function visits each node exactly once, performing constant-time operations for each node.
Auxiliary Space: O(N), primary space usage comes from the recursive call stack, which can grow to a depth of N in the worst case (skewed tree).

The print_tree function is efficient in terms of both time and space complexity for most practical purposes. This method is particularly useful for debugging and understanding the structure of Binary Trees.