1. Computer Science 112 Fundamentals of Programming II Expression Trees

2. A Parse (Expression) Tree Evaluator Source language program Syntax error messages Ok or not OK Parser The value of the expression Semantic error messages A parse tree

3. Trees for Binary Expressions An expression tree for a number is a node containing the number Otherwise, the tree is a node containing an operator and links to left and right subtrees The subtrees contain the operands of the expression

4. Example Expression Trees 23

5. Example Expression Trees 23 3 + 5 + 35 Root node Right subtree Left subtree

6. Example Expression Trees 23 3 + 5 + 35 3 + 5 * 4 + 3* 54 Root node Right subtree Left subtree

7. Example Expression Trees 23 3 + 5 + 35 3 + 5 * 4 + 3* 54 Root node Right subtree Left subtree (3 + 5) * 4 + 35 * 4

8. Operator Precedence 3 + 5 * 4 + 3* 54 (3 + 5) * 4 + 35 * 4 5 * 4 + 3 + * 54 3 Operators with higher precedence appear lower in the tree, unless overridden by parentheses.

9. Operator Precedence 5 * 4 - 3 - * 54 3 When operators have equal precedence, the ones to the left appear lower in the tree. 5 + 4 - 3 - + 54 3 5 + 4 - 3 + 6 - + 54 3 + 6

10. Expression Trees 5 * 4 - 3 - * 54 3 5 + 4 - 3 - + 54 3 5 + 4 - 3 + 6 - + 54 3 + 6 3 3

11. Properties of Expression Trees Numbers are in leaf nodes Operators are in interior nodes All interior nodes have exactly two children Both types of nodes implement the same interface

12. Things We Might Want from an Expression Tree Its value Its prefix form Its infix form Its postfix form

13. Resources # The interface to all expression tree classes value()# Returns the int value of the expression prefix()# Returns a string in prefix infix()# Returns a string in infix (fully parenthesized) postfix()# Returns a string in postfix # Implementing classes LeafNode(data) InteriorNode(opToken, leftOperandNode, rightOperandNode)

14. Evaluating an Expression Tree A leaf node returns the number contained in it An interior node evaluates its left and right subtrees, applies its operator to these values, and returns the result

15. Evaluate This One 3 + 5 * 4 + 3* 54 Contains an operator, so evaluate left and right subtrees

16. Evaluate This One 3 + 5 * 4 + 3* 54 Contains a number, so return 3

17. Evaluate This One 3 + 5 * 4 + 3* 54 Contains an operator, so evaluate left and right subtrees

18. Evaluate This One 3 + 5 * 4 + 3* 54 Contains a number, so return 5

19. Evaluate This One 3 + 5 * 4 + 3* 54 Contains a number, so return 4

20. Evaluate This One 3 + 5 * 4 + 3* 54 Return 5 * 4 = 20

21. Evaluate This One 3 + 5 * 4 + 3* 54 Return 3 + 20 = 23

22. Evaluating a Leaf Node class LeafNode(object): def __init__(self, data): self.data = data def value(self): return self.data # Other methods go here A LeafNode forms the base case for the recursive processing of expression trees

23. Evaluating an Interior Node class InteriorNode(object): def __init__(self, opToken, leftOperandNode, rightOperandNode): self.operator = opToken self.left = leftOperandNode self.right = rightOperandNode def value(self): return self.computeValue(op, self.left.value() self.right.value()) # Other methods go here The method computeValue is the same one we used in the stack-based evaluator

24. Tree Traversals An expression tree supports three types of traversals –preorder (visit the node, then go left, then go right) –inorder (go left, then visit the node, then go right) –postorder (go left, then go right, then the visit node

25. Tree Traversals An expression tree supports three types of traversals –preorder (visit the node, then go left, then go right) –inorder (go left, then visit the node, then go right) –postorder (go left, then go right, then visit the node These traversals can generate the prefix, infix, and postfix notations of an expression

26. Code for postfix class LeafNode(object): def __init__(self, data): self.data = data def postfix(self): return str(self.data) # Other methods go here class InteriorNode(object): def __init__(self, opToken, leftOperandNode, rightOperandNode): self.operator = opToken self.left = leftOperandNode self.right = rightOperandNode def postfix(self): return self.left.postfix() + " " + self.right.postfix() \ + " " + str(self.operator)

27. Generate Postfix 3 + 5 * 4 + 3* 54 Node an operator, so go left def postfix(self): return str(self.data) def postfix(self): return self.left.postfix() + " " + self.right.postfix() \ + " " + str(self.operator)

28. Generate Postfix 3 + 5 * 4 + 3* 54 Node an operand, return "3" def postfix(self): return str(self.data) def postfix(self): return self.left.postfix() + " " + self.right.postfix() \ + " " + str(self.operator)

29. Generate Postfix 3 + 5 * 4 + 3* 54 Now go right 3 def postfix(self): return str(self.data) def postfix(self): return self.left.postfix() + " " + self.right.postfix() \ + " " + str(self.operator)

30. Generate Postfix 3 + 5 * 4 + 3* 54 Node an operator, so go left 3 def postfix(self): return str(self.data) def postfix(self): return self.left.postfix() + " " + self.right.postfix() \ + " " + str(self.operator)

31. Generate Postfix 3 + 5 * 4 + 3* 54 Node an operand, return "5" 3 5 def postfix(self): return str(self.data) def postfix(self): return self.left.postfix() + " " + self.right.postfix() \ + " " + str(self.operator)

32. Generate Postfix 3 + 5 * 4 + 3* 54 Now go right 3 5 def postfix(self): return str(self.data) def postfix(self): return self.left.postfix() + " " + self.right.postfix() \ + " " + str(self.operator)

33. Generate Postfix 3 + 5 * 4 + 3* 54 Node an operand, return "4" 3 5 4 def postfix(self): return str(self.data) def postfix(self): return self. left.postfix() + " " + self. right.postfix() \ + " " + str(self.operator)

34. Generate Postfix 3 + 5 * 4 + 3* 54 Return "*" 3 5 4 * def postfix(self): return str(self.data) def postfix(self): return self.left.postfix() + " " + self.right.postfix() \ + " " + str(self.operator)

35. Generate Postfix 3 + 5 * 4 + 3* 54 Return "+" 3 5 4 * + def postfix(self): return str(self.data) def postfix(self): return self.left.postfix() + " " + self.right.postfix() \ + " " + str(self.operator)

36. Building an Expression Tree Each parsing method builds a tree that represents the portion of the expression for which it is responsible Each parsing method returns its tree to the caller

37. Build a Tree for Primaries # primary = number | "(" expression ")" def primary(self): token = scanner.get() if token.getType() == Token.INT: tree = LeafNode(token.getValue()) scanner.next() elif token.getType() == Token.L_PAR: scanner.next() tree = self.expression() self._accept(scanner.get(), Token.R_PAR, "')' expected") scanner.next() else: tree = LeafNode(token.getValue()) fatalError (token, "unexpected token") return tree

38. Build a Tree for Expressions # expression = term { addingOperator term } def expression(self): tree = self.term() token = scanner.get() while token.getType() in (Token.PLUS, Token.MINUS): scanner.next() tree = InteriorNode(token, tree, self.term()) token = scanner.get() return tree

39. For Friday Heaps