C241 Homework 8. Assigned: Apr. 16, 2009 Due: Apr. 22, 2009

Transcription

1 C241 Homework 8 Assigned: Apr. 16, 2009 Due: Apr. 22, 2009 As we have seen, a tree is a structure with nodes and edges. Each node is connected to 0 or more child nodes by one edge per child. Trees are useful representing many different kinds of information, and you will encounter them frequently as structures for containing data in computer programming. 1. One such use of trees is the representation of mathematical expressions. Simple arithmetic involves four functions or operators: addition (+), subtraction (-), multiplication ( ), and division (/). Each of these functions takes two arguments. We can represent any arithmetic operation as a tree, with the operator as the root node and each of its arguments as a child. For instance, (2+3) would be represented as a tree with the + operator in the root, 2 in the left child, and 3 in the right child Of course, an argument to an arithmetic operation can be another arithmetic expression. 5 (2 + 3) would be represented as a tree with the in the root, 5 in the left child, and the tree for (2 + 3) in the right child. 1

2 Thus, tree representation of an arithmetic expression unambiguously represents the order of evaluation in the expression operations further down the tree must be evaluated first, so that their ancestors in the tree may be evaluated. (a) Construct an expression tree for the expression ((2 3) + (5 7)) (3 + 4)

3 (b) Expression trees for logical expressions can also be built, on similar principles. Construct an expression tree for the expression ((p q) ( q r)) (r p). (Important: How many children does a negation operation have?) r p p q r q (c) Similarly, construct an expression tree for the set-theory expression (A B) C. A B C 2. When working with trees, it is often necessary to visit the tree s nodes one-by-one, a process called traversal. Traversal is usually used to perform some operation, such as printing or searching, on all nodes of a tree. When traversing a tree, we can either travel all the way to the bottom of the tree down one path before examining any other paths (depth-first traversal), or we can visit all the nodes on one level of the tree before proceeding to the next level (breadth-first traversal). 3

4 We will mostly deal with breadth-first traversal in the next problem. Here, we examine three distinct depth-first algorithms. Of these three, pre-order traversal is what people typically mean if they say depthfirst traversal. i. Pre-order traversal: Operate first on the root node, then perform a recursive call down the left subtree, then perform a recursive call down the right subtree. ii. In-order traversal: First perform a recursive call down the left subtree, then operate on the root node, then perform a recursive call down the right subtree. iii. Post-order traversal: First perform a recursive call down the left subtree, then down the right subtree, then operate on the root node. A B C D E F For instance, with the above sample tree, the order in which nodes would be operated on is as follows: i. Pre-order traversal: A, B, D, C, E, F ii. In-order traversal: D, B, A, E, C, F iii. Post-order traversal: D, B, E, F, C, A iv. Breadth-first traversal: A, B, C, D, E, F Do the following problems on traversals. (a) Give the nodes of the following tree in the order they would be operated on by each traversal: i. Pre-order UVWXYZ ii. In-order WVXUYZ iii. Post-order WXVZYU 4

5 iv. Breadth-first UVYWXZ V U W X Z Y (b) We are used to seeing arithmetic expressions in what is called infix notation, where the operator goes between the operands e.g., However, other notations exist. In prefix notation, the operator comes before the operands e.g., In this system, parentheses are unnecessary because the order of operations is unambiguous. (3 + 5) 2, for instance, becomes , which can only be evaluated one way. i. Construct an expression tree for the expression (3 + 5) 2. Which traversal scheme would we use to obtain the same expression back from the tree, but in prefix notation instead of infix? Pre-order traversal. ii. Construct an expression tree for the expression ((2 3) 5) (5 + 7) and give the equivalent expression in prefix notation The equivalent expression in prefix notation is

6 (c) Similarly, in postfix notation, the operator follows the operands e.g., i. What is the postfix notation for (3+5) 2 and which traversal technique would we use to obtain that expression from its expression tree? , and we use post-order evaluation. ii. Does postfix notation require parentheses to show order of operations (like infix), or is it unambiguous without them (like prefix)? Postfix notation is unambiguous without parentheses. iii. Use the expression tree for ((2 3) 5) (5 + 7) again, and give the equivalent expression in postfix notation

7 3. Following is pseudo-code for depth-first traversal and breadth-first traversal. The depth-first function is initially invoked with the root node of the tree as an argument. That way the tree will be evaluated, from the top, in a depth-first (or pre-order) fashion. Note that breadth-first traversal requires a queue to keep the nodes in the correct order for examination. The node at the front of the queue is operated on, and its children are appended to the back of the queue to be operated on later. Initially, the queue contains just the root node of the tree. That way, the tree will be evaluated, one level at a time, from left to right (because the nodes of each level are appended to the queue in order as the level above is traversed). // depth f i r s t t r a v e r s a l void printdfs ( node ) { p r i n t node. getvalue ( ) ; printdfs ( c h i l d ) ; // breadth f i r s t t r a v e r s a l void printbfs ( queue ) { node = queue. g e t F i r s t ( ) ; i f ( node == NULL) r eturn ; queue. removefirst ( ) ; p r i n t node. getvalue ( ) ; queue. append ( c h i l d ) ; printbfs ( queue ) ; (a) Modify both the depth-first and breadth-first algorithms to return true if a given value appears in any node of the tree. (The value will need to be a new argument to each function.) For instance, if your new depth-first function is called findvaluedfs, the call findvaluedfs(root, 2) should return true if any node contains 2 in the tree starting at root. The algorithms should return false if the value is not in the tree. Although it is not necessary to 7

8 include examples in your submission, you may wish to trace your algorithm on some example trees. // depth f i r s t t r a v e r s a l bool finddfs ( node, val ) { i f ( node. getvalue ( ) == val ) return true ; i f ( finddfs ( c h i l d ) ) return true ; r eturn f a l s e ; // breadth f i r s t t r a v e r s a l bool findbfs ( queue, val ) { node = queue. g e t F i r s t ( ) ; i f ( node == NULL) return f a l s e ; queue. removefirst ( ) ; i f ( node. getvalue ( ) == val ) return true ; queue. append ( c h i l d ) ; findbfs ( queue, val ) ; 8

9 (b) Modify both the depth-first and breadth-first algorithms to return the number of nodes whose value matches a provided value (which, again, will need to be a new argument to each function). This is very similar to part (a), but we are counting the total number of times we see the value, instead of simply returning true the first time. For instance, if your new breadth-first function is called nummatchesbfs, the call nummatches(root, 3) should return 5 if there are 5 nodes containing the value 3 in the tree starting at root. Again, examples are not required, but you may wish to test your algorithm. // depth f i r s t t r a v e r s a l i n t countdfs ( node, val ) { count = 0 ; i f ( node. getvalue ( ) == val ) count = count + 1 ; count = count + countdfs ( c h i l d ) ; r eturn count ; // breadth f i r s t t r a v e r s a l i n t countbfs ( queue, val ) { count = 0 ; node = queue. g e t F i r s t ( ) ; i f ( node == NULL) return count ; queue. removefirst ( ) ; i f ( node. getvalue ( ) == val ) count = count + 1 ; queue. append ( c h i l d ) ; count = count + countbfs ( queue, val ) ; r eturn count ; 9