Since inorder traversal produces an infix expression and preorder traversal produces a prefix expression, it should not come as a surprise that postorder traversal produces a postfix expression. In a postfix expression, an operator always follows its operands. The beauty of postfix (and prefix) expressions is that parentheses are not necessary.

A simple postorder traversal of the tree in Figure gives the postfix expression

In Section we saw that a postfix expression is easily evaluated using a stack. So, given an expression tree, we can evaluate the expression by doing a postorder traversal to create the postfix expression and then using the algorithm given in Section to evaluate the expression.

In fact, it is not really necessary to first create the postfix expression
before computing its value.
The expression can be evaluated
by making use of an *evaluation stack*
during the course of the traversal as follows:
When a terminal node is visited, its value is pushed onto the stack.
When a non-terminal node is visited,
two values are popped from the stack,
the operation specified by the node is performed on those value,
and the result is pushed back onto the evaluation stack.
When the traversal terminates,
there will be one result in the evaluation stack
and that result is the value of the expression.

Finally, we can take this one step further. Instead of actually evaluating the expression, the code to compute the value of the expression is emitted. Again, a postorder traversal is done. However, now instead of performing the computation as each node is visited, the code needed to perform the evaluation is emitted. This is precisely what a compiler does when it compiles an expression such as Equation for execution.

Copyright © 1997 by Bruno R. Preiss, P.Eng. All rights reserved.