Postorder Traversal of Binary Tree | DSA Tutorials

YASH PAL,

Postorder Traversal of a Binary Tree – In postorder traversal of a binary tree, we first traverse the left subtree of the root node, then the right subtree of the root node, and then we traverse the root node of the binary tree.

Postorder Traversal of a Binary Tree

  1. Traverse the left subtree of the root in postorder
  2. Traverse the right subtree of the root in postorder
  3. Visit the root node.

Let’s say we have a binary tree, as you see in Figure 1. 

Postorder Traversal of Binary Tree
Figure 1: Postorder Traversal of Binary Tree

To find the postorder of this tree, we need to first divide the tree into the subtrees, as you see in Figure 1. And as we know, in postorder, we need to visit the left subtree, the right subtree and then the root node of the tree. So the preorder of this tree is 

B C P

But B is also a subtree, so the postorder of B is D E A. So the postorder of the tree is

D E A C P

Now the D is also a subtree, so the postorder of D is T Q S. So the postorder of the tree is

T Q S E A C P

Now the E is also a subtree, so the postorder of E is D E. So the postorder of the tree is

T Q S D E A C P

Now the C is also a subtree, so the postorder of C is F G X. So the postorder of the tree is

T Q S D E A F G X P

But the F is also a subtree, so the postorder of F is M. So the postorder of the tree is

T A S D E A M G X P

But the G is also a subtree, so the postorder of G is C R. So the postorder of the tree is

T A S D E A M C R X P

This is the complete postorder of the binary tree.

Program to find the postorder of a binary tree using Python.

from collections import deque


class Node:
    def __init__(self, value):
        self.info = value
        self.lchild = None        self.rchild = None

class BinaryTree:
    def __init__(self):
        self.root = None
    def is_empty(self):
        return self.root is None
    def display(self):
        self._display(self.root, 0)
        print()

    def _display(self,p,level):
        if p is None:
            return        self._display(p.rchild, level+1)
        print()

        for i in range(level):
            print(" ", end='')
        print(p.info)
        self._display(p.lchild, level+1)

    def preorder(self):
        self._preorder(self.root)
        print()

    def _preorder(self,p):
        if p is None:
            return        print(p.info, " ", end='')
        self._preorder(p.lchild)
        self._preorder(p.rchild)

    def inorder(self):
        self._inorder(self.root)
        print()

    def _inorder(self,p):
        if p is None:
            return        self._inorder(p.lchild)
        print(p.info," ", end='')
        self._inorder(p.rchild)

    def postorder(self):
        self._postorder(self.root)
        print()

    def _postorder(self,p):
        if p is None:
            return        self._postorder(p.lchild)
        self._postorder(p.rchild)
        print(p.info," ",end='')

    def level_order(self):
        if self.root is None:
            print("Tree is empty")
            return
        qu = deque()
        qu.append(self.root)

        while len(qu) != 0:
            p = qu.popleft()
            print(p.info + " ", end='')
            if p.lchild is not None:
                qu.append(p.lchild)
            if p.rchild is not None:
                qu.append(p.rchild)

    def height(self):
        return self._height(self.root)

    def _height(self,p):
        if p is None:
            return 0
        hL = self._height(p.lchild)
        hR = self._height(p.rchild)

        if hL > hR:
            return 1 + hL
        else:
            return 1 + hR

    def create_tree(self):
        self.root = Node('p')
        self.root.lchild = Node('Q')
        self.root.rchild = Node('R')
        self.root.lchild.lchild = Node('A')
        self.root.lchild.rchild = Node('B')
        self.root.rchild.lchild = Node('X')


##########################
bt = BinaryTree()

bt.create_tree()

bt.display()
print()

print("Preorder : ")
bt.preorder()
print("")

print("Inorder : ")
bt.inorder()
print()

print("Postorder : ")
bt.postorder()
print()

print("Level order : ")
bt.level_order()
print()

print("Height of tree is ", bt.height())
Data Structures & Algorithms Tutorials for Beginners
Computer Science Tutorials Data Structures Tutorials

Leave a Reply

Your email address will not be published. Required fields are marked *