What Is Polish Expression in Data Structure?


Heather Bennett

Data structures are an essential part of computer science and play a crucial role in organizing and managing data efficiently. One commonly used data structure is the Polish expression, also known as the Reverse Polish Notation (RPN). The Polish expression is a mathematical notation that eliminates the need for parentheses to denote the order of operations.

What is Polish Expression?

A Polish expression is a way of writing arithmetic expressions in which the operators are written after their operands. In other words, instead of writing “3 + 4”, we write “3 4 +”. This notation was introduced by Jan Lukasiewicz, a Polish logician, hence the name “Polish expression”.

Let’s consider an example to understand how the Polish expression works:

  • Expression: 3 + 4
  • Polish Expression: 3 4 +

In this example, we first write the operand “3”, followed by the operand “4”, and finally, we write the operator “+”. This notation allows us to perform arithmetic operations without using parentheses to specify the order of operations.

Advantages of Using Polish Expression

The use of Polish expression provides several advantages over other notations such as infix or postfix. Here are some key advantages:

  • Simplicity: The Polish expression eliminates the need for parentheses and provides a simple and unambiguous representation of arithmetic expressions.
  • Ease of Evaluation: Evaluating a Polish expression is straightforward as it follows a fixed pattern. Operators are always applied to their preceding operands.
  • No Operator Precedence Rules: In traditional infix notation, the order of operations is determined by operator precedence rules. However, Polish expression eliminates the need for such rules as the order of operations is explicitly defined by the position of operators.

Implementing Polish Expression

To evaluate a Polish expression, we can use a stack data structure. The algorithm for evaluating a Polish expression using a stack is as follows:

  1. Create an empty stack.
  2. Read the expression from left to right.
  3. If the element is an operand, push it onto the stack.
  4. If the element is an operator, pop two operands from the stack, perform the operation, and push the result back onto the stack.
  5. Repeat steps 3 and 4 until all elements in the expression are processed.
  6. The final result will be stored at the top of the stack.

This algorithm ensures that arithmetic operations are performed correctly based on their position in the Polish expression.


Let’s apply this algorithm to evaluate a simple Polish expression:

  • Polish Expression: 5 3 +
  1. Create an empty stack.
  2. Read “5” and push it onto the stack.
  3. Read “3” and push it onto the stack.
  4. Read “+” (operator). Pop “3” and “5” from the stack. Perform addition (5 + 3 = 8) and push “8” onto the stack.

The final result is stored at the top of the stack, which is “8”. Therefore, the value of the Polish expression “5 3 +” is 8.


The Polish expression is a mathematical notation that represents arithmetic expressions without the need for parentheses. It provides simplicity, ease of evaluation, and eliminates operator precedence rules. By using a stack data structure, we can efficiently evaluate Polish expressions and obtain accurate results.

Now that you understand what Polish expression is and its advantages, you can explore further applications and implement it in your own programs to enhance efficiency and clarity in arithmetic calculations.

Discord Server - Web Server - Private Server - DNS Server - Object-Oriented Programming - Scripting - Data Types - Data Structures

Privacy Policy