CMPT 280 Intermediate Data Structures and Algorithms

Transcription

1 The University of Saskatchewan Saskatoon, Canada Department of Computer Science CMPT 280 Intermediate Data Structures and Algorithms Assignment 6 - SOLUTIONS 1 Solutions Written Questions 1. (10 points) For each part below, give the diagram for the 2-3 tree that results after performing all of the operations below in the order specified. Be sure to follow the algorithms for insertion into and deletion from a 2-3 tree. You can give the diagrams for the intermediate trees of a part if you wish, but it is not necessary. Only the final tree is required. Solution: Only the final answer is required. The tree after each part is provided for reference only. (a) Into an empty 2-3 tree insert the following: 3,10, and (b) Into the 2-3 tree from the previous part, insert 25 and then (c) Into the 2-3 tree from the previous part, insert * (d) Into the 2-3 tree from the previous part, insert 22 and then 15.

2 * (e) For the 2-3 tree from the previous part, delete * 15 * (f) For the 2-3 tree from the previous part, delete (g) Into the 2-3 tree from the previous part, insert * (h) Into the 2-3 tree from the previous part, insert 24 and then * 24 * 18 * Page 2

3 (i) For the 2-3 tree from the previous part, delete 15. Final Answer: (10 points) The algorithm for building a kd-tree from a set of N-dimensional points is: Algorithm kdtree ( pointlist, int depth ) pointlist - list of points from which to build a kd - tree depth - the current depth in the partially built tree if pointlist is empty return nil ; else // Select axis based on depth so that axis cycles through all valid values d = depth mod k; // Sort point list and choose median as pivot element medianpoint = select the median point in dimension d from pointlist ; // Create node and construct subtrees tree_node node node. item = pointlist node. leftchild = kdtree ( points in pointlist before median, depth +1); node. rightchild = kdtree ( points in pointlist after median, depth +1); return node ; Using the above algorithm build a kd-tree from the following list of points: (1, 2, 1), (8, 1, 2), (2, 1, 6), (7, 3, 3), (3, 7, 5), (6, 4, 4), (4, 6, 1), (5, 5, 7) You only need to show your final answer. Solution: (4, 6, 1) (1, 2, 1) (7, 3, 3) (2, 1, 6) (3, 7, 5) (8, 1, 2) (6, 4, 4) (5, 5, 7) Page 3

4 Programming Questions This assignment is open-ended and could be designed in a number of different ways so the marking scheme is not as specific as on previous assignments. When marking, use the following guidelines: Perfect (100%) : Nothing to possibly criticize. Almost Perfect (90-99%) : One or two very minor mistakes or inefficiencies. Very good (80-89%) : A few minor improvements could be made, maybe one major mistake. Good (70-79)% : General approach is correct, some major and minor mistakes and inefficiencies. Fair (60-69)% : General approach is mostly correct and/or major mistakes in methods, few bits of the code are unimplemented or not fully complete. Passable (50-59)% : Serious flaws in the general approach, and/or large portions of code missing, but a genuine attempt. Fail (< 50%) : (Use judgement) Approach is completely wrong and/or many missing classes. Not really a serious attempt to solve the assignment. Mark Breakdown 1. (30 points) Watch for these common mistakes. If they do them, deduct the suggested amount of marks (exercise judgement), but not more than once. -8 if one of the major methods (partition, insertkd, lookup) is left empty. Otherwise, partial credit after deduction of major/minor mistakes. up to -6 for the regression test. If they show a tree with least 3 levels, and display them using tostring() for human verification, that is sufficient. Should be small enough to easily verify by eye though. -5 if they changed anything they weren t supposed to (e.g. extra methods, add/remove parameters on existing methods, add instance variables, etc.). up to -3 (max) for commenting/documentation. -3 for other major mistakes -2 for other minor mistakes -1 for other very minor mistakes 2. (10 points) The expected results here are that if you keep the search range narrow, you should see a time difference of roughly 2 orders of magnitude. They also need to use a set of points that is large enough, because with very small point sets, the overhead of recursion in the kd-tree will make it seem to perform worse. A minimum of 1000 points is probably needed, 5000 would be better. Don t expect more than because at that point you risk blowing out the system stack in partition(), particularly if the input list of points is already sorted (e.g. (1,1,1), (2,2,2), (3,3,3)... ). Watch for these common mistakes. If they do them, deduct the suggested amount of marks (exercise judgement), but not more than once. -2 If they timed anything other than the search time. They should not time construction of the tree. The linear search should include the time for adding the result to an ArrayList though, because timing lookup() would also include such time. -2 for insufficient number of points in test. -1 for too large a search range to demonstrate the advantage of kd-trees. If they search a range that encompasses the whole tree, then the tree will probably be slower. If they explained this though, that s OK, don t deduct. -2 for other major mistakes Page 4

5 -1 for other minor mistakes 3. (15 points) Pretty much any design that works is probably OK. It doesn t matter whether the sort is done in the constructor or via a method call. But there should be a separate movedown() method since it is used both to heapify, and to do the actual heapsort. Watch for these common mistakes. If they do them, deduct the suggested amount of marks (exercise judgement), but not more than once. -3 Uses additional memory other than the input array - all the work should be done within the input array. -2 Does not require input array to be Comparable -2 No separate movedown() method -1 if movedown() not public (do not deduct if you deducted -2 for no separate movedown()) Up to -2 for testing in most cases one test will be sufficient, showing both the input array and the sorted array to be verified by eye. It doesn t matter what data type is being sorted, as long as it s Comparable (this includes things like Integer, Double) and it is obvious what the correct ordering should be. -2 for other major mistakes -1 for other minor mistakes Page 5