What is Postfix Expression?

A postfix expression (also called a reverse Polish notation expression) is an arithmetic expression in which the operands (numbers) appear before their operators. The expressions are written in a style in which each operator follows its operands.

Here is an example of a postfix expression:

5 1 2 + 4 × + 3 −

This expression can be evaluated as follows:

The operands 5, 1, and 2 are pushed onto a stack.

The + operator is encountered, so the top two operands (2 and 1) are popped off the stack, added together, and the result (3) is pushed back onto the stack.

The 4 is pushed onto the stack.

The × operator is encountered, so the top two operands (4 and 3) are popped off the stack, multiplied together, and the result (12) is pushed back onto the stack.

The + operator is encountered, so the top two operands (12 and 5) are popped off the stack, added together, and the result (17) is pushed back onto the stack.

The 3 is pushed onto the stack.

The − operator is encountered, so the top two operands (3 and 17) are popped off the stack, and the result (14) is pushed back onto the stack.

The final result of the expression is 14.

Postfix expressions can be evaluated using a stack, as shown above. They are easier to evaluate using a computer because they do not require the use of parentheses to specify the order of operations.

Here are a few more points about postfix expressions:

Postfix expressions are also known as reverse Polish notation (RPN) expressions, named after the mathematician Jan Łukasiewicz, who invented them.

In a postfix expression, the operator follows its operands, rather than preceding them as it does in infix notation (the most common way of writing arithmetic expressions). This means that the order of the operands in a postfix expression is the same as the order in which they appear in the original infix expression.

The main advantage of postfix notation is that it does not require the use of parentheses to specify the order of operations. This makes it easier to parse and evaluate using a computer.

To evaluate a postfix expression, a stack is used to store the operands as they are encountered in the expression. When an operator is encountered, the top two operands are popped off the stack, the operator is applied to them, and the result is pushed back onto the stack.

It is possible to convert an infix expression to a postfix expression using a stack. This can be done by using the stack to store the operators and applying the rules of operator precedence to determine the order in which the operators should be applied.

Some examples of postfix expressions and their equivalent infix expressions are shown below:

Postfix expression      Infix expression

--------------------         ----------------

5 1 2 + 4 × + 3 −        ((5 + 1 × 2) × 4 + 3) −

2 3 1 × + 9 −              2 + 3 × 1 − 9

1 2 + 3 × 4 −              1 + 2 × 3 − 4

Postfix expressions can be evaluated using a stack and a set of rules. The rules for evaluating a postfix expression are as follows:

If the element is an operand, push it onto the stack.

If the element is an operator, pop the top two elements from the stack, apply the operator to them, and push the result back onto the stack.

It is possible to convert a postfix expression to an infix expression using a stack. This can be done by scanning the postfix expression from left to right and applying the following rules:

If the element is an operand, push it onto the stack.

If the element is an operator, pop the top two elements from the stack, enclose the operator and the two operands in parentheses, and push the resulting infix expression back onto the stack.

Some programming languages (such as FORTH and PostScript) use postfix notation as their primary method of expressing arithmetic expressions.