# What Are Expression Trees in Data Structure?

//

Heather Bennett

Expression trees are an important concept in data structures, particularly in the field of computer science. They represent mathematical expressions in a tree-like structure, which allows for efficient evaluation and manipulation of the expressions. In this article, we will explore what expression trees are and how they can be used.

What is an Expression Tree?

An expression tree is a binary tree that represents a mathematical expression. Each node in the tree corresponds to an operator or an operand.

Operators can be arithmetic operators such as addition (+), subtraction (-), multiplication (*), or division (/), or they can be logical operators such as AND (&&) or OR (||). Operands, on the other hand, are the values on which operators operate.

Creating an Expression Tree

To create an expression tree, we need to follow certain rules. The expression should be fully parenthesized and follow the operator precedence rules. The first step is to convert the infix notation expression into postfix notation using techniques like the Shunting Yard Algorithm or stack-based approaches.

Once we have converted the infix notation to postfix notation, we can easily construct the expression tree. We start by creating an empty stack and traverse through each token in the postfix expression from left to right.

If we encounter an operand, we create a new node with that value and push it onto the stack. If we encounter an operator, we pop two nodes from the stack, create a new node with that operator as its value, and make those popped nodes its children.

## Example:

Consider the infix notation expression: 3 + 4 * 2 – 6 / 3

The corresponding postfix notation is: 3 4 2 * + 6 3 / –

We can construct the expression tree using this postfix notation:

“`

/ \
+ /
/ \ / \
3 * 3
/ \
4 2
“`

Evaluating an Expression Tree

Once we have constructed the expression tree, we can evaluate the expression by traversing the tree in a recursive manner. Starting from the root node, if we encounter an operand node, we simply return its value. If we encounter an operator node, we recursively evaluate its left and right subtrees based on the operator’s functionality.

For example, to evaluate the expression tree above:

1. Traverse to the left subtree of the root node (+): Evaluate 3 + 4 * 2. 2.

Traverse to the right subtree of the root node (/): Evaluate 6 / 3. 3. Subtract the results from steps 1 and 2: (3 + 4 * 2) – (6 / 3) = (3 + 8) – (2) = 9.

Applications of Expression Trees

Expression trees find applications in various areas such as compilers, calculators, and symbolic mathematics systems. They are particularly useful in evaluating mathematical expressions efficiently and accurately.

• Compilers: Expression trees play a crucial role in parsing and evaluating arithmetic expressions during compilation.
• Calculators: Expression trees can be used to build calculator applications that can handle complex mathematical expressions.
• Symbolic Mathematics Systems: Expression trees enable symbolic mathematics systems to manipulate algebraic expressions symbolically.

### Conclusion

In conclusion, expression trees provide an efficient way to represent and evaluate mathematical expressions. They are created by converting infix notation expressions into postfix notation and constructing a binary tree based on that postfix notation.

The evaluation of expression trees involves recursively evaluating operators and operands. The applications of expression trees span across various domains such as compilers, calculators, and symbolic mathematics systems.

So next time you encounter a mathematical expression that needs to be evaluated, you can rely on expression trees to simplify the process and make it more efficient.