Solutions to Exam Data structures (X and NV)

Transcription

1 Solutions to Exam Data structures X and NV a Insert the keys 9, 6, 2,, 97, 1 into a binary search tree BST. Draw the final tree. See Figure 1. b Add NIL nodes to the tree of 1a and color it as a red-black tree. See Figure 1. c Denote the left and right subtrees of an internal node x by L and R, respectively. Consider a BST with the property that heightl heightr heightl + 1 for all internal nodes x. Is this BST balanced? Argue why or why not. Since this condition is stronger than the AVL condition, the tree is balanced. That is, its height h is bounded by the logarithm of the number of nodes n. d Assume that the height of each node is stored as an attribute. Give pseudocode for a recursive operation that checks whether the property of 1c holds. Call the following routine. Supply the root of the tree as parameter. checkproperty1cnode x { if x NIL return checkproperty1cx.left && checkproperty1cx.right && x.left.h x.right.h && x.right.h x.left.h+1 else return true NIL 97 1 NIL NIL NIL NIL NIL Figure 1: A red-black BST of the keys given in 1a. Red nodes are indicated by dashed circles. NIL nodes are black. 1

2 e The expected height of a randomly built BST is bounded by Olg n. In the text book proof, the relation n 1 i + n + is used. Prove this relation via induction. For the base case when n 1, 0 i + 1, 1 and 1 holds. For the induction step, assume that 1 holds for n N 1. For n N + 1, we then have N i + N + + N 1 i + N + + N + by the induction hypotheses. This is equal to N +!!N! Thus, + N +! N +! + NN +!!N 1!!N! N i + N + N +!.!N! which means that 1 holds for N + 1 as well. By the induction axiom, it then holds for all n a What is Strassen s algorithm used for? State its time complexity. Strassen s algorithm is used for multiplying two n n matrices. Its complexity is Θn lg 7. b For a symmetric positive-definite n n matrix B, we can compute B 1 in time T spd n OSn, where Sn is the complexity of Strassen s algorithm. Use this fact to explain how A 1 for any nonsingular n n matrix A can be computed in time T n OSn. Use the following algorithm: i Construct A T. ii Compute B A T A. iii Compute B 1. iv Compute A 1 B 1 A T. 2

3 All of these steps are OSn, and the total time is therefore OSn. Note that step iii is ok because A T A is known to be symmetric and positive-definite for a nonsingular A, and step iv works because B 1 A T A T A 1 A T A 1 A T A T A 1.. a Consider a hash table with m 7 slots, where collisions are resolved via chaining. Give a sequence of 5 different keys which would result in a maximal number of collisions when inserted into the table. Use a hash function hk k mod m. One sequence is 0, 7, 1, 21, 28. All keys hash to the slot 0, and we have collisions. b Consider a hash table with m 7 slots, where collisions are resolved via open addressing and linear probing. Explain linear probing, and give a sequence of 5 different keys which would result in a maximal number of collisions when inserted into the table. Linear probing is when the first probe is given by a hash function h, for instance the same as in a, and a sequence of probes is given by h i k hk + i mod m, i 0,..., m 1. The same sequence as in a gives collisions. c Consider a hash table with m 7 slots, where collisions are resolved via double hashing. Explain double hashing, and give a sequence of 5 different keys which would result in a maximal number of collisions when inserted into the table. Double hashing is when the first probe is given by a hash function h, for instance the same as in a, and a sequence of probes for i 0,..., m 1 is given by h i k hk+igk mod m, where g is another hash function, for instance gk 1+k mod m 2. If hk k mod 7, and gk 1+k mod 5, the following sequence of keys gives 10 collisions: 7, 0, 5, 70, 105. This is because all keys have hk 0, and all keys except 7 have gk 1. d Suppose that an application will store n 100 keys in a hash table. The hash table should be designed to have less than probes on average for an unsuccessful search. How many slots should at least be allocated if chaining is used? How many slots should at least be allocated if double hashing is used? For double hashing, the expected number of probes for an unsuccessful search is 1 u d 1 n/m. For chaining, the expected number of probes is u c 1 + n/m,

4 a b c d e Figure 2: Sorting via heapsort. a The heap after buildheap. b e The heap after each call to heapify. Nodes no longer in the heap are indicated by dotted circles. or just u c n/m, depending on how you define a probe. Set u d gives m n 1. Set u c gives m n/ or m n/ 25. It is not necessary to answer with the next larger prime.. a The recurrence for the time complexity of mergesort is T n 2T n/2 + Θn. Explain why. Use the recursion-tree method to derive a tight bound. Mergesort is a divide and conquer algorithm which splits the array in two subarrays of length n/2, sorts these subarrays recursively, and merges them together into a sorted array. Each recursive call costs T n/2 and the merging costs Θn. See text book, Figure 2.5, for a recursion tree. The tight bound is Θn lg n. b Suppose mergesort is modified to always produce a -to-1 proportional split. Give the recurrence for the time complexity of the modified version. Use the recursion-tree method to derive an upper bound. The recurrence becomes T n T n/ + T n/ + Θn. See text book Figure 7., for a similar recursion tree. The height

5 becomes log / n, and the most shallow leaf has depth log n. The asymptotic upper bound is On lg n. c Use heapsort to sort the array A {6, 9, 2,, 17. Illustrate the array as a heap after buildheap and after each call from heapsort to heapify. See Figure 2. d On average, quicksort is Θn lg n. One way of showing this is by considering the number X of comparisons required. Derive E[X] as a sum of probabilities. Rename the elements of A as z 1,z 2,...,z n, with z 1 < z 2 <... < z n. For 1 i < j n, introduce indicator random variables { 1 zi is compared to z X ij j 0 else. Since X n 1 n i1 ji+1 X ij, and since E[X ij ] Pr{z i is compared to z j, we get E[X] n 1 n i1 ji+1 Pr{z i is compared to z j. See text book on how to proceedl; however, this expression answers the actual exam question. kruskalgraph G { Set A DisjointSet DS for all u G.V DS.makeSetu sort G.E w.r.t. wu,v // Declare an empty set of edges // Declare a disjoint-set // Needed! for all u,v G.E if DS.findSetu DS.findSetv DS.unifyu,v A A u,v return A Figure : Kruskal s algorithm 5

6 5. a A disjoint-set datastructure provides the operations makeset, findset and unify. A Disjoint-set data structure is used for example in Kruskal s algorithm which is outlined in exam Figure 1. However, an important point is missing. Explain, using the graph shown in Figure, what might go wrong. Complete the algorithm. The sorting of the edges with respect to weight must be performed. Corrected version appears in Figure. If the edges are not traversed in order, the algorithm may produce a spanning tree as in Figure, and this is obviously not a minimum spanning tree. b Explain the linked-list representation of disjoint sets. Explain particularly the weighted-union heuristic. The linked-list representation represents each disjoint set as a list, and each node of the list has a pointer reference to the set representative. This makes findset fast, O1. A naive implementation of unify would unify two sets A and B by traversing and updating the set representative of all elements of, say, B. If B contains more elements than A, this is inefficient. If the weighted-union heuristic is used, unify will always update the pointers of the elements of the smaller set. c If the elements of a disjoint-set are integers in [0, K 1], a disjoint-set forest may be represented by a single array of K integers. Explain how, and use this representation to give pseudocode for makeset and findset with the path compression heuristic. See figure 5. The crux is that the entries of the array points to the parents. Thus, the number p[i] refers to the parent of node i. 6. The edges of a sparse, undirected, graph may be represented by an adjacency matrix, an adjacency list, an adjacency BST, or by using a hash table. a 5 b 12 c 22 Figure : Thick edges indicate a spanning tree which is not an MST 6

7 Explain the first two representations. The adjacency BST is similar to the adjacency list representation, but instead of a linked list u.adjlist, the neighbors v to u are stored in a binary search tree u.adjbst. Suggest two ways of using a hash table. Discuss the advantages and disadvantages of the different representations with respect to time and space complexity. For example, what is the expected time for determining whether an edge is in the graph, if you assume that all edge lookups are equally likely? This question is more of an essay question, and both the information you present as well as the structure of your answer have implications for the grading. Nevertheless, here is a list of various information that I think is relevant. matrix The matrix representation uses an V V matrix to store the edges. Memory is V 2. In this case, the graph is undirected, which means that only half the memory is actually required. For an unweighted graph, one bit per edge is enough. This representation is nevertheless expensive in terms of memory, if the graph is sparse. Edge lookups are very fast. However, in many applications DFS, BFS, Prim, Dijkstra, etc. it is more relevant to iterate through all edges from a given node. This is quite costly with the adjacency matrix representation, OV. list The list representation stores an edge u, v as a list element v in the adjacency list of u. For an undirected graph, an edge u, v is stored twice, both in the adjacency list of u and of v. The required memory for an undirected graph is V + 2 E. For a sparse graph, this is much more efficient memory-wise than the matrix representation. Edge lookups are relatively slow, though. The situation is pretty much the same as when we analyze collision resolution via chaining. The average list length is α 2 E / V the 2 comes from the undirectedness of the graph, and the formulas for unsuccessful and successful search in a hash table with chaining apply. For applications where we iterate through outgoing edges from a given node, the list representation is very good, though. This is because the average list length α is much less than V when the graph is sparse. tree The tree representation has the advantage over the list representation that edge lookups become faster. If a balanced tree is used and if the number of outgoing edges from a given node u is L, it costs Olg L to determine if u, v exists. It is also possible to relatively fast O1 in amortized time iterate through all 7

8 outgoing edges from u. The disadvantage compared to the list representation is that we need to store two pointers per tree node compared to one pointer per list node, and we also have some extra overhead for traversing the tree etc. Asymptotically, the memory is still OV + E. hash Hash tables can be used either as a way to store the outgoing edges from each node u.adjhashtable or to just store all edges of the graph in a table G.edgeHashtable. An advantage with the latter variant is that the undirectedness of the graph can be easily exploited. The memory requirement is OV + E for the u.adjhashtable variant and OE for the G.edgeHashtable variant. Both variants are good O1 for edge lookups, but not as fast as the adjacency matrix. Compared to the matrix, the memory consumption is more efficient. Both hash table variants are bad in terms of iterating through all edges u, v from a given node u. General grading strategy: For 1 point, you are able to explain the adjacency matrix and the adjacency list representations and you have about 25% of the information above. For 2 points, you should have a sense for which representations are good for edge lookups, and about 50% of the information above. For points, you should have suggested the two hash table variants and have about 70% of the info above. For points, you should have about 90% of the info above. For and points, I expect that you have commented upon the disadvantage with hash tables and the adjacency matrix when edges from a given node should be iterated thtough. In addition, the info should also be well structured. 8

9 class DisjointSet { private: int p[k] ; // array with K integers public:... void makeset int x { p[ x ] x ; int findset int x { if p[ x ]! x p[ x ] findset p[ x ] ; return p[ x ] ; void unify int x, int y { ; int xrepr findset x ; int yrepr findset y ; p[ xrepr ] yrepr ; Figure 5: An efficient implementation of integer disjoint sets as a forest represented in an array. The unify operation was not asked for but given here for completeness. 9