TREES. Week 8 Laboratory for Introduction to Programming and Algorithms Uwe R. Zimmer based on material by James Barker. Pre-Laboratory Checklist

Transcription

1 TREES Week 8 Laboratory for Introduction to Programming and Algorithms Uwe R. Zimmer based on material by James Barker Pre-Laboratory Checklist vvskills: You can understand and write conditional, recursive and polymorphic programs. vvknowledge: You know what exhaustive and non-overlapping guards are and can apply this to your programming tasks. vvknowledge: You experienced that types are sometimes an alternative of multiple possibilities, like e.g. with the Maybe type or enumerations. vvknowledge: You know how conditions can be based upon pattern matching, boolean guards, or a mixture of both. vvknowledge: You understand the difference between polymorphism and overloading. vvyou have read the laboratory text below. Introduction For the last few weeks, you have been working regularly with Haskell s built-in list data structure. In this lab, you will gain experience with another kind of recursive data structure: trees. You will learn how to define different kinds of trees, and how to perform useful operations over them. You will build a module encapsulating your binary search tree code for future use. Important Note If you do not finish this lab in time, you should ensure that you complete it before next week. This is for two reasons. The first is that following labs will build on the code you have written this week. The second is that tree data structures will come in super-handy for assignment 2, and completing this lab promptly will put you in a better position to excel in the assignment. Interlude: Motivating Trees You should already be deeply familiar with the list data structure. You might recall several labs ago that I introduced a definition of lists of integers that is equivalent to the standard Haskell version []: data My_String = Empty_String Attach My_String 1 ANU College of Engineering and Computer Science April 2015

2 We have since covered polymorphism, so you should now fully understand the generalisation: data a = Empty_ Attach a ( a) (If you don t understand this, you should talk to your tutor immediately.) This is a recursive definition: a of type a is either empty, or an element of type a followed by a of type a of [5, 3, 4, 3, 0, 1] = 5 : 3 : 4 : 3 : 0 : 1 : [ ] :: [] Moreover, this definition is exactly equivalent to the standard Haskell definition. The diagram above should remind you of the recursive structure of lists. Although lists are easy to understand and work with, they are not necessarily the best choice of data structure for any given problem. In this lab, you will be introduced to another type of recursive data structure: the tree. There are several different types of trees. We will start with the simplest kind: the binary tree. A binary tree can be defined recursively by analogy to lists: a binary tree is either An empty, or null, tree. (This is similar to the empty list, i.e. the base case.) A node, which contains an element and links to two subtrees, either or both of which can be null. (This is similar to the case of a non-empty list, i.e. the step case.) Here is an algebraic type definition for binary trees: data Binary_Tree a = Null Node a (Binary_Tree a) (Binary_Tree a) Even better you can also use this amended definition which gives your individual Node components labels otherwise it is completely identical with the above (purely positional, i.e. the components are identified only by their position in a sequence of expressions) definition: data Binary_Tree a = Null Node {element :: a, left_tree, right_tree :: Binary_Tree a} Binary_Tree of 2 ANU College of Engineering and Computer Science April 2015

3 Those labels not only make the product type more readable, but also serve automatically as functions to extract those components out of a Node. Note the strong similarity between this definition and that for lists above. The only real structural difference is that the step case of the definition includes two recursive elements rather than one. We will call these links the left subtree and right subtree respectively. Above is a diagram of a sample binary tree of s. If you re still struggling to see what s going on, return to the list diagram above. Rotate the page 90 degrees clockwise so that the list moves down the page towards you. You should be able to see that a list is, in a sense, a unary tree each subtree is either null (empty), or a node with one subtree. When you understand this, the generalisation to binary trees is actually quite sensible. (This interpretation isn t very useful, but I provide it to help you develop your intuition for what a tree actually is.) Exercise 1: Exercise 1 (Basic Binary Tree Manipulation) Open a new script file, called Binary_Tree.hs. Copy the following definition into it: data Binary_Tree a = Null Node {element :: a, left_tree, right_tree :: Binary_Tree a} Save the file and load it in GHCi. Verify that the following is a legitimate value of type Binary_ Tree Double: > Node 13.2 (Node 7.9 (Node 2.0 Null Null) (Node (-18.0) Null Null)) (Node 3.2 Null Null) (The best way to do this is to simply type it into GHCi, and ensure that it is parroted back to you without errors. Once you ve done this, you can execute :type it to be sure. The it is a handly little feature of GHCi that always takes the value of the last legitimate, i.e. error-free, expression that you entered.) As you can tell, this syntax is clumsy and difficult to read. There s very little that can be done about this: because of their bifurcating nature, binary trees simply aren t as easy to express in writing as lists. Nevertheless, you will quickly develop the intuition to parse expressions like this. Grab a pen and a piece of paper, and draw a similar diagram to the one above that shows the structure of this tree. Check this diagram with your tutor. You will now gain some practice writing functions that operate on binary trees. To begin, write a function size_of_tree :: (Integral b) => Binary_Tree a -> b that calculates the number of nodes in a tree. Realise that this is very similar in concept to calculating the length of a list. Return to or quickly re-write the general list_length :: Integral b => [a] -> b function, and try to generalise the logic. (Hint: you may find it helpful to first copy my alternative list definition above into a script file, and write an equivalent function list_length :: Integral b => a -> b.) If you calculate the size of the tree I gave you, it should return 5. Then write a function depth_of_tree :: Integral b => Binary_Tree a -> b. The depth of a tree is the number of levels it contains; for example, the example tree I gave above has a depth of 3. (You might like to consider how the size of a tree and its depth are related.) Now, write a function flatten_tree :: Binary_Tree a -> [a]. This function should take a binary tree and return a list containing all the elements contained in that tree. You can also perform a simple sanity check on your function and test that the lengths of the returned list should be the size of the tree (as your calculated it above). Similarly, write a function 3 ANU College of Engineering and Computer Science April 2015

4 leaves_of_tree :: Binary_Tree a -> [a]. This function should take a binary tree and return a list containing the leaves of that tree that is, all the nodes with no subtrees beneath them. You can test your functions over the following sample values: test_case_1, test_case_2 :: Binary_Tree Float test_case_1 = Node 0.0 Null Null test_case_2 = Node 10.9 Null (Node (-1.0) Null Null) test_case_3 :: Binary_Tree String test_case_3 = Node Galvanic (Node metal (Node beats Null Null) (Node stomp Null Null)) (Node out Null (Node louder Null Null)) Submit your code now to the SubmissionApp ( under Lab 8 Binary Tree. The code you have just implemented (hopefully correctly!) is likely to be useful in future. Therefore, it makes sense to export it as a module so that you can use it again. The following code will do this: add it to the top of your script file, save, and exit. module Binary_Tree ( Binary_Tree (Null, Node, element, left_tree, right_tree), size_of_tree, -- :: Integral b => Binary_Tree a -> b depth_of_tree, -- :: Integral b => Binary_Tree a -> b flatten_tree, -- :: Binary_Tree a -> [a] leaves_of_tree, -- :: Binary_Tree a -> [a] ) where Exercise 2: Higher tree functions While we did not yet introduce higher order functions in full, here comes a simple exercise which demonstrates this concept for trees. The only extension here is that you pass on a function as a parameter. This handed-over-as-a-parameter function can then be used inside your higher-order function just like any other function which is visible. Thus write a higher-order function called map_function_over_binary_tree :: (a -> b) -> Binary_Tree a -> Binary_Tree b. This function should behave similarly to the standard map higher-order function: it should take a function and a tree, and return the tree obtained by applying that function to all elements contained in the nodes of the tree (and keep the tree structure). Hence the return type is Binary_Tree b, e.g. a tree where the elements are of type b, which is the return type of the function we just handed over. Submit your code now to the SubmissionApp ( under Lab 8 Binary Tree higher. Your code will now offer one additional function, so add it to your module definition: module Binary_Tree ( Binary_Tree (Null, Node, element, left_tree, right_tree), size_of_tree, -- :: Integral b => Binary_Tree a -> b depth_of_tree, -- :: Integral b => Binary_Tree a -> b flatten_tree, -- :: Binary_Tree a -> [a] leaves_of_tree, -- :: Binary_Tree a -> [a] map_function_over_binary_tree -- :: (a -> b) -> Binary_Tree a -> Binary_Tree b ) where 4 ANU College of Engineering and Computer Science April 2015

5 Interlude: Binary Search Trees By now you should be beginning to get a feel for how trees operate, and how you can manipulate them. However, like all new syntax, it s not much good without an example, so let s construct one. The canonical example of binary trees in use is to provide a dictionary data type; that is, a data type that stores some number of elements and admits queries on that storage. You could certainly implement a dictionary type with lists you might like to imagine how. However, using lists for this purpose is potentially inefficient. Suppose you want to query whether or not an element exists in a dictionary, which is implemented as a list of N elements. On the assumption that the list is randomly ordered, looking up an entry will take, on average, N 2 operations. (Convince yourself that this is a reasonable statement before you continue.) This is fine for small dictionaries, but consider a phonebook containing several hundred thousand phone numbers. What happens if you want to look up a hundred numbers? Or a thousand? Clearly, this will be slow. So, how can we use binary trees to provide a more efficient experience? We can introduce a special kind of binary tree: the binary search tree. This is no different structurally to a standard binary tree, but it must satisfy an additional property: given any binary search tree with element x, it must be the case that every element e l in the left subtree is strictly less than x. Similarly, every element e r in the right subtree must be strictly greater than x. This is referred to as the binary search tree ordering constraint. (You should see that this immediately puts a restriction on the types of elements we can store in our tree, namely that they must be in a particular typeclass. Which?) What does this property do? At first glance, it might seem quite arbitrary. However, when this property is satisfied, searching the tree for an element becomes very easy and efficient. Start at the root node. If the element you re looking for is less than the element contained at the root, then you can completely forget about the other half of the tree and search only the left-hand subtree, and similarly if the element you are searching for is greater than the root element. You can then recursively search the interesting half of the tree. On the assumption that the tree is balanced (i.e. that one side is not much larger than the other), you can find an element of the tree in log2 ] Ng operations, rather than N 2. This is significantly faster! (We will return to the notion of efficiency and tree balance next week. For the moment, you should keep it in mind but not worry too much about it.) A phonebook is, again, a good analogy. If I m looking for, say, Cedric s Cakes, I can open a phonebook more-or-less at random. If I find myself at the page containing Monica s Muffins, then because the phonebook is in alphabetical order, I can ignore every page after 'g' the one I opened. I can then repeat the process, splitting the left-hand half of the phone book about halfway, perhaps finding the entry for Bob s Bakery. I now only have 'c' 'i' to worry about the pages between the two entries I ve just found. If I repeat this, I will find the entry for Cedric s Cakes much 'a' 'e' 'h' 'j' quicker than if I laboriously read through the book from the start. Here is a simple binary search tree containing the letters a through j, using standard alphabetical ordering. Convince yourself that this tree satisfies the binary search tree ordering property. If you aren t sure how this works, check with your tutor or discuss with a fellow student. 'b' 'd' 'f' Binary Search Tree of 5 ANU College of Engineering and Computer Science April 2015

6 Exercise 3: Binary Search Trees Create a new script file, called Binary_Search_Tree.hs. Do not write these functions in your earlier binary tree module. You can define a binary search tree very easily: simply note that a binary search tree is, structurally, a binary tree: type BS_Tree a = Binary_Tree a (You will need to import your previously-written Binary_Tree module.) Of course, this definition does not capture the ordering constraint. There is no easy way in Haskell to define the type in a way that ensures satisfaction of the ordering constraint. (I m not even sure that there s a hard way.) However, we do need a way to check. Therefore, define a function is_valid_binary_search_tree :: Ord a => BS_Tree a -> Bool that returns True if and only if the input tree satisfies the ordering constraint. Hint: a BS_Tree is valid if the maximum element in the left subtree is less than the element at the root, similarly for the right subtree, and both subtrees are valid binary trees. A BS_Tree is also valid if the flattened tree (if cleverly flattened) results in a sorted list. Your implementation could end anywhere between a one liner and a code massacre. If getting out of hand: step back, let it rest and do something else first. Now write some simple functions to query a BS_Tree. You should write the functions minimum_element :: Ord a => BS_Tree a -> a maximum_element :: Ord a => BS_Tree a -> a contains_element :: Ord a => a -> BS_Tree a -> Bool Of course, you should use the ordering constraint when working out how to write these functions. You should also reimplement the function flatten_in_order :: Ord a => BS_Tree a -> [a] (if you didn t already do so as part of your is_valid_binary_search_tree function). Given the ordering constraint, you should be able to write this function in such a way that the resulting list is produced in such a way that it is already sorted into ascending order. Up to this point, we have been using pre-existing trees for test values. This is not particularly useful: in the phonebook example, it would be difficult in the extreme to manually construct a properly-ordered binary search tree. (In fact, it would be difficult to construct any non-trivial tree manually, full stop.) So we need to write a function to add an element to a binary search tree. (Of course, this function must maintain the ordering constraint.) We will call this function insert_element_to_tree :: Ord a => a -> BS_Tree a -> BS_Tree a. How can we do this? It s not actually that hard, and uses very similar logic to that which we used to search a BS_Tree. The basic idea is to move down through the tree until we find an fitting spot to place the new element. Here is a simple English description of the (recursive, of course) algorithm you will use: a. Investigate the root node of the tree. b. if this node is Null, then return a new Node containing the new element. c. if the element at this node is identical to the element to be inserted, then return the tree (effectively not actually inserting anything, but omitting the new element as a duplicate). d. If the element at this node is greater than the element to be inserted, then insert the element into the left-hand subtree. e. If the element at this node is less than the element to be inserted, then insert the element into the right-hand subtree. Take some time to read this algorithm and make sure you understand it. How can you be sure that the resulting tree still maintains the ordering constraint? You might like to experiment on 6 ANU College of Engineering and Computer Science April 2015

7 paper to try and see what s going on. Don t be afraid to ask your tutor this is a tricky idea and it may take some explanation before it makes sense to you. As always, you should test your code. Load up your script into GHCi and try to build a binary search tree by repeatedly calling the insert_element_to_tree function. Use the is_valid_binary_tree function to make sure that the ordering constraint remains satisfied after each insertion. Play around with your minimum_element, maximum_element and contains_element functions. Basically, persuade yourself that everything works like you expect. After you have completed your insert_element_to_tree function, compare your solution with the version used in the lectures. How is yours different? Here are some sample value to test your functions with: test_case_4 :: BS_Tree test_case_4 = Node g (Node c (Node a Null (Node b Null Null)) (Node e (Node f Null Null) (Node g Null Null))) (Node i (Node h Null Null) (Node j Null Null)) test_case_5 :: BS_Tree test_case_5 = Node 92 (Node 11 Null Null) (Node 101 Null (Node 102 Null Null)) (You might wonder how to delete elements from a binary tree. It can of course be done, but it is quite a bit more fiddly. We will return to this next week.) Finally submit your code to the SubmissionApp ( under Lab 8 Binary Search Tree. Check out the code which you receive for peer review. Take especially note of the function is_valid_binary_search_tree. Is this function way shorter or longer than yours? More efficient? Slower? Exercise 4: Arithmetic Tree Expressions You remember the evaluation of arithmetic token lists you did in lab five? (Take a quick walk down memory lane and look it up if you don t.) Wouldn t it have been great to know about trees back then? Well, now you do, so let s do it again only this time this will be an affair of a few lines of code. Given these definitions (start in a new file): data Expression a = Number a Node (Expression a) Operand (Expression a) data Operand = Plus Minus Times Divided_By Power write a function with the profile: eval :: Floating a => Expression a -> Expression a which evaluates any given expression to an expression which only contains a single number. Such that > eval (Node (Node (Number (3 :: Double)) Times (Node (Number 1) Plus (Number 1))) Power (Node (Number 4) Divided_By (Number 2))) will result in: Number 36.0 You will notice that you will not need the function binding_power any more (as we needed it for the list expressions). Why is that? 7 ANU College of Engineering and Computer Science April 2015

8 Trees are commonly used not only for storing and searching data, but also to express structured data like the above arithmetic expressions in a natural and unambiguous way. Submit your code now to the SubmissionApp ( under Lab 8 Arithmetic Tree Expressions. After submission add a module header to your new expression code: module Tree_Expressions ( Expression (Number, Node), Operand (Plus, Minus, Times, Divided_By, Power), eval -- :: Expression -> Expression ) where so that you can refer to it later again. Exercise 5: Rose Trees "The" String "quick" "jumps" "undergrad" String String String of Rose_Tree Rose_Tree "brown" "fox" "over" "the" "lazy" "student" String String String String String String of Rose_Tree of Rose_Tree of Rose_Tree Rose_Tree In this lab, we are only scratching the surface of the possibilities of trees. To finish off, we will introduce a new tree structure. The new tree structure is called a rose tree (I don t know why, it just is I m not much of a gardener), and unlike the binary trees you ve worked with so far, each node can have any number of children. (None, one, two, three, or as many as you like.) Note that there is no requirement for two nodes in the same tree to have the same number of elements. How can we implement this? You ve already seen a data type that allows you to store an arbitrary number of elements: the list. So consider the following definition: data Rose_Tree a = Rose_Node a [Rose_Tree a] 8 ANU College of Engineering and Computer Science April 2015

9 Again, this might appear cryptic, but it s not that bad compare it with the binary tree definition above. All it says is that a rose tree is a node, with an element of type a, and a list containing the potentially-many subtrees of that node. The diagram above should help you understand what s going on. (Note that the above definition does not explicitly allow for a null node. How can you express a rose tree node with no children?) Create a new script file, Rose_Tree.hs, and copy the above definition into it. Implement the following functions appropriately: size_of_tree :: Integral b => Rose_Tree a -> b depth_of_tree :: Integral b => Rose_Tree a -> b leaves_of_tree :: Rose_Tree a -> [a] (hint: consider the concatmap higher-order function from the Prelude.) map_function_over_rose_tree :: (a -> b) -> Rose_Tree a -> Rose_Tree b Test your functions using the following sample values: test_case :: Rose_Tree test_case = Rose_Node 1 [Rose_Node 2 [], Rose_Node 3 [Rose_Node 4 []], Rose_Node 5 [Rose_Node 6 [], Rose_Node 7 []]] If you fully understood this lab as well as the last one, then your functions above should all be between one and three lines long. Submit your code to the SubmissionApp ( under Lab 8 Rose Tree. Check out the code which you receive for review. How does this code compare to yours in terms of efficiency/maintainability? Add the following header to your code: module Rose_Tree ( Rose_Tree (Rose_Node), size_of_tree, -- :: Integral b => Rose_Tree a -> b depth_of_tree, -- :: Integral b => Rose_Tree a -> b leaves_of_tree, -- :: Rose_Tree a -> [a] map_function_over_rose_tree -- :: (a -> b) -> Rose_Tree a -> Rose_Tree b ) where for future usage. If you are even more curious check out how rose trees are defined in Data.Tree (a default Haskell library). Make Sure You Logout to Terminate Your Session! Outlook In a few weeks you will put your trees to work and use them to implement another important data-structure: the set. Next week we will turn to higher order functions thought. 9 ANU College of Engineering and Computer Science April 2015