PIC 16: Midterm. Part 1. In this part, you should not worry about why your class has the name that it does.

Transcription

1 PIC 16: Midterm Assigned 10/19/2018 at noon. Code (a single.py file) due by 12:51pm on CCLE. I have provided you with a.py file which contains test code. I have also provided you with a.txt file of what my code outputs when I run this test code. In this midterm, you will create a class named SpecialTree to implement a sorting algorithm. Part 1. In this part, you should not worry about why your class has the name that it does. Questions. [ points] 1. Write a new class SpecialTree. For now, its only method should be an initializer, and the only instance variable should be an empty list - data. 2. (a) Write a magic method so that you can print the data in instances of SpecialTree quickly. (b) Write a magic method so that the built-in function len returns the number of elements in instances of SpecialTree. 3. To your SpecialTree class, add a method swap that accepts two indices i1 and i2 and swaps the corresponding entries in data. (I do not require your method swap to be able to handle bad indices from a useless user!) 1

2 Part 2. In what follows, we will think of our data as arranged in an special type of tree... We think of each value as being contained within a node (represented with a rectangle). Arrows pointing away from a node point to the node s children. Arrows pointing towards a node come from the node s parent. We call the top node, which is not the child of any other node, the root of the tree. We call each node that has no children a leaf. Three properties we ll always impose are: Each node has zero, one, or two children. Each level/row is full except for the last. There are no gaps in the last level (which is filled from left to right). This means that: The index of the parent of node i is (i-1)/2 (using int division). The indices of the children of node i are 2i+1 (left) and 2i+2 (right). An example when len(data)==6... data[0] 0 1 data[1] data[2] 2 3 data[3] data[4] 4 5 data[5] 2

3 Questions. [0 + 8 points] 1. Add a method parent that accepts an index i and returns the index of the parent of node i: if i==0: return None return (i-1)/2 Notice that if node i is the root of the tree, then parent returns None (which is correct). This code is already in the.py file I gave you (commented out). 2. Add a method child that accepts an index i and returns the index of the child of node i that contains a greater value. Some clarification is necessary since it is possible for a node to have two children, one child, or even zero children. When node i has two children, it should return the index of the left child exactly when value_left_child_contains > value_right_child_contains. When node i has one child, child should return the index of that child. When node i has no children, child should raise an IndexError. However, your code should NOT use the keyword raise. I d use try-except to make this easier. In the example below, we d have child(0)==1, child(1)==4, child(2)== In the example below, calling child(2) would raise an IndexError

4 Part 3. We demand one final property of our SpecialTrees: If p is a parent node of c, then the value of p is greater than or equal to the value of c. We call this the special property. Not all trees have the special property. For instance, does not because node 0 is the parent of node 1, but 8 is not bigger than or equal to 9. Questions. [ points] 1. Add a method push that accepts a value to be added to an instance of SpecialTree: self.data.append(value) active = len(self) - 1 while parent!= None and self.data[active] > self.data[parent]: self.swap(active, parent) active = parent This code is already in the.py file I gave you (commented out). This implements an algorithm which ensures the special property is maintained. 2. Make it an option for your SpecialTree initializer to accept any sequence/container and construct a SpecialTree out of its elements. 3. Add a method pop that returns the greatest element in the SpecialTree and removes it from the SpecialTree while maintaining the special property. Here s the algorithm: Swap the root in the SpecialTree with the last leaf (i.e. swap the first and last elements of the list). Remove the last leaf. This is what you want to return. Label the root as the active node. Compare the value of the active node to that of its greater child. (see over page...) 4

5 For example, If the value of the child is greater than that of the active node, swap the child and active node. Then go back to the beginning of this bullet point. If the value of the child is less than or equal to that of the active node or if the active node has no children (i.e. it is a leaf), stop. We swap 7 and We remove 7 and will return it later The root is the active node We swap 2 and 6. Node 1 becomes the active node. We swap 2 and 5. Node 4 becomes the active node. We stop Make your SpecialTree iterable by: copying it (by using the initializer cleverly) and popping elements one by one, until it has no elements. To receive the final point, you should accomplish this by only adding one additional method. If you cannot complete question 3, use self.data.pop() instead of self.pop(). 5

6 Solution. class SpecialTree: def init (self, container = []): self.data = [] for el in container: self.push(el) def str (self): return str(self.data) def len (self): return len(self.data) def swap(self, i1, i2): self.data[i1], self.data[i2] = self.data[i2], self.data[i1] def parent(self, i): if i==0: return None return (i-1)/2 def child(self, i): l = self.data[2*i+1] try: r = self.data[2*i+2] except IndexError: return 2*i+1 if l > r: return 2*i+1 return 2*i+2 def push(self, value): self.data.append(value) active = len(self) - 1 while parent!= None and self.data[active] > self.data[parent]: self.swap(active, parent) active = parent def pop(self): self.swap(0, len(self)-1) for_returning = self.data.pop() 6

7 active = 0 while True: try: child = self.child(active) except IndexError: return for_returning if self.data[child] > self.data[active]: self.swap(active, child) active = child return for_returning def iter (self): copy = SpecialTree(self.data) while len(copy) > 0: yield copy.pop() 7