CS2 Practical 6 CS2Bh 24 January 2005

Transcription

1 CS2 Practical 6 Data Structures for Dictionaries This practical is based on material of the Algorithms and Data Structures thread. It has two parts: Part A, worth 40 marks, consists of four pen-and-paper exercises. In Part B, worth 60 marks, you are asked to analyse and implement different data structures for dictionaries and run experiments with the data structures to complement the theoretical analysis. This practical has been issued on Monday 24th January, and the deadline for submitting your answers is 11am on Monday 14th February. Late submissions will only be accepted in the case of genuine mitigating circumstances, for example illness, and with the agreement of the course organiser. The submission process is detailed below. Resources Download the file prac6.jar, which can be found in the directory Copy the file into a new directory and unpack it using the command jar xf prac6.jar. Your directory should now contain the following files: ArrayDictionary.java BArrayDictionary$Item.class BArrayDictionary.class BTreeDictionary$Node.class BTreeDictionary.class Dictionary.java Experiment.java ListDictionary.java TreeDictionary.java cformat (cformat is a directory itself). Part A Problem 1: (10 marks) Two functions f, g : N R may be in the following four relations with respect to their asymptotic growth rate: 1

2 (R1) (R2) (R3) (R4) f(n) Θ(g(n)), f(n) O(g(n), but g(n) O(f(n)), g(n) O(f(n)), but f(n) O(g(n)), f(n) O(g(n)) and g(n) O(f(n)). For each of the following pairs of functions f, g : N R, determine which of the relations (R1) (R4) they are in: a. f(n) = n lg(n) and g(n) = n n/2. b. f(n) = 7 n(n 2 n + n lg(n)) and g(n) = n(n 1)(n 2) c. f(n) = n i=0 i2 and g(n) = n i=1 i d. f(n) = { 1 if n is even 2 if n is odd and g(n) = { 3 if n is even 4 if n is odd e. f(n) = n and g(n) = { n 2 if n is even 1 if n is odd Problem 2: (10 marks) Determine the asymptotic running time of the algorithms alg1 alg5. Each of the algorithms takes a natural number n as its input. The running time is to be measured in terms of n, that is, your answers are supposed to be of the form Θ(f(n)), for some function f (such as f(n) = n 2 or f(n) = n lg n). You do not have to justify your answers. Algorithm alg1(n) 2. for i 0 to n 1 do 3. for j 0 to n 1 do 4. s s + 1 Algorithm alg2(n) 2. for i 0 to n 1 do 3. for j 0 to n 2 1 do 4. s s + 1 2

3 Algorithm alg3(n) 2. for i 0 to n 1 do 3. for j i to n 1 do 4. s s + 1 Algorithm alg4(n) 2. i n 3. while i > 0 do 4. s s i i/2 Algorithm alg5(n) 2. for i 1 to n do 3. j i 4. while j > 0 do 5. s s j j/2 Problem 3: (10 marks) Determine the asymptotic running time of the algorithm bubblesort. Justify your answer in detail. Algorithm bubblesort(a) Input: An integer array A Output: Array A sorted in non-decreasing order 1. do 2. done TRUE 3. for i 0 to A.length 2 do 4. if A[i] > A[i + 1] then 5. exchange A[i] and A[i + 1] 6. done FALSE 7. while (not done) Hint: Take the analysis of insertionsort in ADS LN2 as an example of how such an analysis might look and what level of detail is required. 3

4 Problem 4: (10 marks) Suppose you are given a set of small boxes, numbered 1 to n, identical in every respect except that each of the first i contains a pearl whereas the remaining n i are empty. You have two magic wands that can test if a box is empty or not in a single touch. The twist is that a wand disappears if you test it on an empty box. You want to determine the value i (which tells you exactly which boxes contain pearls). Describe a method for doing so by just touching the boxes with your two wands. Try to use as few wand touches as possible. Hint: A good method will require less than Ω(n) wand touches, no matter what i is. Part B Dictionaries In the context of algorithms and data structures, a dictionary stores key element pairs, which are called items. Several elements may have the same key. A dictionary provides three basic methods: findelement(k): If the dictionary contains an item with key k, then return the element of such an item, otherwise return the special element NO SUCH KEY. insertitem(k, e): Insert an item with key k and element e. removeitem(k): If the dictionary contains an item with key k, then delete such an item and return its element, otherwise return the special element NO SUCH KEY. Note that removeitem(k) removes just one item with key k and not all of them (if there is more than one such item), and likewise for findelement. Figure 1 shows a JAVA interface for the dictionary abstract data type. public interface Dictionary { public static final Object NO_SUCH_KEY = null; } public Object findelement(comparable key); public void insertitem(comparable key,object element); public Object removeitem(comparable key); Figure 1: Dictionary interface in JAVA. As the name says, a dictionary data structure can be used to store a dictionary, for example with keys being English words and elements being their translations into German. In general, dictionaries can be seen as a simple type of database. They have numerous applications in all areas of computing. 4

5 What you are supposed to do In this part of the practical, you will analyse, implement, and experiment with three completely different data structures for dictionaries. The first one stores items in a linked list. I have already implemented it in the class ListDictionary. The second one stores items in an array. I have only set up the frame for this (in a class ArrayDictionary). You will have to implement all the methods. The third one is based on binary search trees (see LN25 of CS1Ah). I have already implemented the method insertitem, but you will have to implement findelement and removeitem. For all three classes I have implemented a method tostring which prints all items of a dictionary to the standard output. This method is not required by the Dictionary interface, but is very useful for testing purposes. Your second task is to analyse the worst-case running time of all the methods for each of the three different data structures. Your third task is to experiment with the data structures. I have already implemented a class Experiment.java which you can use to run your experiments. Details I. Implementation (25 marks) Nothing needs to be done for ListDictionary. In the class ArrayDictionary the items are stored in an array ordered by increasing keys. Ordering the keys is possible since they are objects of type Comparable. Two keys k1, k2 can be compared using the method k1.compareto(k2). See the Java API documentation for the interface Comparable for details. The advantage of storing items in this ordered fashion is that findelement can (and should) be implemented using binary search. You have to implement the methods ArrayDictionary.findElement, ArrayDictionary.insertItem, and ArrayDictionary.removeItem. A problem with the array representation is that arrays have a fixed size and are not extendible. So if the array is full and additional items are to be inserted, a new array must be created and all items must be copied to this new array. Do not use JAVA Vectors instead of arrays; it is part of your task to resolve this problem for arrays. In general, you must not use the classes of the package java.util in this practical. It is one of the goals of the Algorithms and Data Structures thread to understand the data structures that are used to implement the JAVA classes in java.util. Therefore, we want to avoid using these classes when building such data structures. 5

6 The class TreeDictionary is based on binary search trees. I have already set up the basic data structure and implemented TreeDictionary.insertItem. You have to implement the remaining two methods TreeDictionary.findElement and TreeDictionary.removeItem. You can find all necessary details in LN25 of CS1Ah. Just note that in our dictionary tree the data field of a Node is replaced by the two fields key and element. Of course the keys are used to determine the position of an item in the tree. Also note that I have implemented the method insertitem iteratively, i.e., using a loop, instead of recursively, as CS1Ah LN25 suggests. The main reason for this is that it makes the running time analysis a bit easier, at least with the mathematics available to us. It also tends to be more efficient. But clearly it is less elegant. So overall you have to implement 5 methods. Each is worth 5 marks. Marks are given on grounds of correctness and efficiency (3 marks for correctness and 2 for efficiency). As a benchmark for the efficiency, I will use straightforward implementations of the algorithms. The JAVA bytecode of these benchmark implementations is available in the files BArrayDictionary.class and BTreeDictionary.class. If your implementation is significantly slower, you will lose marks. And remember that you must not use the package java.util. II. Analysis (20 marks) Analyse the worst-case running times of the methods findelement, insertitem, and removeitem of all three classes ListDictionary, ArrayDictionary, and TreeDictionar and determine their asymptotic growth rates. As the input size n, take the number of items currently stored in the dictionary. Your analysis should result in expressions like Θ(n 2 ) or Θ(lg(n)). Briefly justify your results. Directly analyse the JAVA code; there is no need to re-write your algorithms in pseudo code. Assume that each line of code can be executed with O(1) computation steps, i.e., in constant time. There is a serious problem with this assumption when calling methods such as Object.equals or Comparable.compareTo. Briefly explain what the problem is, maybe by giving an example of a dictionary application where this may be relevant. Also explain why this problem is not significant if keys are integers or strings of fixed length. You can get up to 2 additional marks for a short discussion of these issues. 6

7 III. Experiments (15 marks) Now we want to complement the theoretical running time analysis by experiments showing how the different dictionary data structures behave on random inputs. Of course the running time of the algorithms will depend on the keys. In our experiments, we use integers as keys. In many practical dictionary applications, keys will indeed be integers, so this is a reasonable assumption. Moreover, it is easy to generate random integers. The running time of the methods should not depend on the elements contained in the dictionaries. Therefore, we use the same element element with all keys. So our basic procedure is to generate random integers, wrap them into Integer objects key, and then insert items key,element into the dictionaries. This way we obtain dictionaries that are somewhat random. Now we want to measure the average time it takes to find an element in, insert an item into, or remove an item from a dictionary of a certain size. There is a problem in that we can only measure time intervals of milliseconds, but a single operation usually takes less than a millisecond. To resolve this, we first generate an array with many random keys and then measure how long it takes to find, insert, remove all of them. For insertions and removals, this causes another problem: Each insertion or removal changes the size of the dictionary. So we do not actually measure the average time needed by an insertion into a dictionary of fixed size, but the average time needed to insert items into dictionaries of varying sizes (similarly for removals). To be precise, we measure the average time it takes to insert an element into ListDictionarys of size 0, 1,..., n 1. The class Experiment has a method runexperiment(string dictionarytype,string method) that you can use to run your experiments. The first argument dictionarytype is supposed to be the name of a class implementing the Dictionary interface, and the second argument method is supposed to be one of the three methods of the interfaces, i.e., insertitem, findelement, or removeitem. runexperiment(string dictionarytype,string method) prints a table to the standard output that shows the results of the experiments described above for the Dictionary of implementation dictionarytype and the method method. Run experiments for all three Dictionary implementations and all three methods and save the results (9 tables in total) in a file experiment.results Interpret these results and compare them to the theoretical results obtained in the worst case running time analysis. In particular, you will observe that the methods of TreeDictionary perform much better than the worst-case analysis predicts. Can you explain this? You can get up to 5 marks for the file experiment.results and up to 10 marks for a correct interpretation of the results. 7

8 Submission The deadline for this practical is 11am on Monday 14th February. Hand in the files ArrayDictionary.java experiment.results TreeDictionary.java using the command handin P6 < filename > Hand in your written answers, which are required in Part A and Part B II. and III, to the ITO. Assessment Assessment of your written answers will obviously be based on their correctness, but also on the clarity of your exposition. Try to be concise. Assessment for your implementations will include marks that depend on how your code behaves on a test suite, and also marks for commented and readable code. In addition, in this practical your marks will also depend on the efficiency of your code. As usual, to get reasonable marks: You must submit code that compiles. You should test your code yourself on a number of suitably chosen test cases to ensure that it works. You must submit following the instructions above. (I.e. you must give the files the correct filenames, and you must use the handin command.) Your tutor will mark your submission according to a standard marking scheme and will indicate your score for each question. The total mark out of 100 is also allocated a grade according to the University marking scale: G < 25 F < 35 E < 40 D < 50 C < 60 B < 70 A. This is the second of the four practicals in CS2Bh. Each practical is worth equal credit, and the four together make up 25% of the final mark for CS2Bh. Remember that you will need at least a grade C (i.e. at least 50%) in your final CS2 mark to proceed to any of the Computer Science or Software Engineering single or joint honours courses. You should also bear in mind the guidelines on plagiarism, which can be found via a link on the CS2 Web page. Don Sannella 8