CSE 143 Sp03 Final Exam Sample Solution Page 1 of 13

Transcription

1 CSE 143 Sp03 Final Exam Sample Solution Page 1 of 13 Question 1. (3 points) Java classifies exceptions as either checked or unchecked. For each of the following, indicate whether it is checked or unchecked by circling the correct answer. NullPointerException checked unchecked IOException checked unchecked IllegalArgumentException checked unchecked Question 2. (4 points) Both quicksort and mergesort have an expected time of O(n log n) to sort a list containing n items. However, in the worst case, quicksort can require O(n 2 ) time, while mergesort s worst case running time is the same as its expected time, O(n log n). (a) What accounts for the difference in worst case times? How is it that quicksort can require O(n 2 ) time, while mergesort always guarantees O(n log n)? Mergesort always divides the list in half, resulting in two subproblems of size n/2 and a maximum recursion depth of log n, giving a total running time of O(n log n). If quicksort s partition function also divides the list in half each time, the running time will be the same as mergesort O(n log n) but if it repeatedly picks either the largest or smallest element in the list as the pivot, there will be n recursive calls, resulting in a total running time of O(n 2 ). (b) Given that mergesort s worst case time is better than quicksort s, why bother ever to use quicksort at all? (i.e., why is quicksort so commonly used in practice?) Quicksort s advantage is that it can sort a list in place, while mergesort needs a second list to merge the results of the subproblems. Since it is possible in practice to pick a good pivot value and get quicksort to run in O(n log n), the fact that it doesn t need the extra space makes it the method of choice.

2 CSE 143 Sp03 Final Exam Sample Solution Page 2 of 13 Question 3. (4 points) Class Object contains a hashcode() method that is either inherited or overridden by every Java class. (a) Suppose we have a hash table that contains nbuckets buckets (initialized somewhere else). Complete the following line of code so it returns the bucket in which the given object should be stored. int nbuckets; // number of buckets (initialized elsewhere) // return the bucket number for obj public int bucketnumber(object obj) { return obj.hashcode() % nbuckets ; (b) When a Java class is defined, if it overrides method hashcode() by giving a new definition for that method, the class should normally also override equals(). What should be true about the relationship between the values returned by these two methods? If, for two objects o1 and o2, the result of o1.equals(o2) is true, then o1.hashcode() should be the same as o2.hashcode(). [Reason: two objects that are equal should hash to the same bucket. Note that the converse need not be true. o1.hashcode() == o2.hashcode() does not necessarily imply that o1.equals(o2). o1 and o2 might be two different objects with the same hash code a collision.] Question 4. (4 points) Draw a balanced binary search tree containing the following strings: cat, dog, bird, cow, pig, rat, ferret. Use normal alphabetical (dictionary) ordering to decide where to put the words in the tree. dog cat pig bird cow ferret rat (This is the only tree that got full credit. Trees that were not balanced or were not quite binary search trees received some partial credit.)

3 CSE 143 Sp03 Final Exam Sample Solution Page 3 of 13 Question 5. (6 points) During the quarter we ve looked at several different ways of storing a collection of objects, in particular: Lists based on arrays Single- and double-linked lists Trees, particularly binary search trees Hash tables For each of the following applications, indicate which data structure would be most appropriate and give a brief explanation justifying your choice in a technical way using, among other possibilities, the O() times needed to perform various operations. (a) Online telephone directory. Lookups by last name are extremely frequent hundreds per second. Insert and delete operations are less frequent, but there still are many per minute. Once each year the entire directory needs to be printed out in alphabetical order by last name. A hash table would be best since it can perform lookup, insert, and delete in O(1) time (assuming a good hash function and a large enough table). It will take O(n log n) time to produce a sorted copy of the directory, but that is done so infrequently that it doesn t need to be particularly fast. (Answers that recommended a binary search tree received partial credit. This data structure can search, insert, and delete in O(log n) time, and produce a sorted list in O(n) time.) (b) List of students in a class during registration. Students add and drop fairly frequently, and compulsive instructors insist on being able to get up-to-date, sorted alphabetically, class lists via whenever a student adds or drops. The operations that need to be fast are add, delete, and traversing the list in order. A binary search tree can implement all of these operations in O(log n) time, so it would be the best choice. (c) Computerized waiting line at the Department of Licensing driver s license examination station. Employees at the reception desk need to be able to record the names of people as they arrive, then call out their names when they get to the head of the line. The appropriate data structure for this is a queue (an ordered list), and the operations that need to be fast are adding a new name at the rear of the queue and removing a name from the front. A linked list or circular array implementation can perform both operations in O(1) time, either of these would be the best choice.

4 CSE 143 Sp03 Final Exam Sample Solution Page 4 of 13 Question 6. (12 points) Consider the following class definitions: public class Alpha { public Alpha() { System.out.println("Alpha constructor"); public void one(){ System.out.println("Alpha one"); public void two(){ System.out.println("Alpha two"); public class Beta extends Alpha { public Beta() { System.out.println("Beta Constructor"); public void one() { System.out.println("Beta one"); public void iii() { System.out.println("Beta iii"); two(); public class Gamma extends Beta { public Gamma() { super(); System.out.println("Gamma constructor"); public void two() { System.out.println("Gamma two"); public void iii() { System.out.println("Gamma iii"); two(); super.iii(); In each of the question parts on the next page, indicate the output produced when the group of statements in that part is typed into a DrJava interactions window. Assume that each group of statements starts with an empty, newly reset interactions window. If a statement results in either a compile-time or runtime error, show all of the output that would be produced prior to that statement, then describe the error. Hint: Be sure you notice that there are println statements in the constructors this time. You can tear out this page if you want so you can refer to it without having to flip back and forth while answering the questions.

5 CSE 143 Sp03 Final Exam Sample Solution Page 5 of 13 (a) Beta b = new Beta(); b.one(); Alpha constructor Beta constructor Beta one b.iii(); Beta iii Alpha two (b) Alpha a = new Beta(); Alpha constructor Beta constructor a.one(); Beta one a.iii(); Error: no iii method in class Alpha (c) Beta b = new Gamma(); Alpha constructor Beta constructor Gamma constructor b.one(); Beta one (d) b.iii(); Beta b = new Alpha(); b.one(); Gamma iii Gamma two Beta iii Gamma two Error: incompatible types in assignment [not executed] b.iii(); [not executed]

6 CSE 143 Sp03 Final Exam Sample Solution Page 6 of 13 Question 7. (6 points) Consider the following method definitions. public void going(int n) { int j = 0; int k = n; while (j < k) { System.out.println("*"); j++; k--; public void bythree(int n) { int k = 1; while (k < n) { System.out.println("*"); k = k*3; public void gone(int n) { for (int i = 0; i < n; i++) { for (int j = i; j > 0; j--) { going(n); For each of the following statements, give the running time as a function of n using O( )- notation. (a) going(n); O(n) (b) gone(n); O(n 3 ) (c) for (int k = 0; k < n; k++) { bythree(n); O(n log n)

7 CSE 143 Sp03 Final Exam Sample Solution Page 7 of 13 Question 8. (15 points) Another Blast From The Past! For this problem, we re returning to the iterator class for doubly-linked lists from the 2 nd midterm. Recall that an iterator provides a constructor and methods hasnext(), next(), and remove(). It turns out that iterators for linked lists also provide a method add(), which you are to implement for this problem. When add(obj) is called, the given object is inserted in the list between the most recent object returned by next() and the following object, which is the one that will be returned by next() when it is called again. add() can be called as many times as desired between successive calls to next(). If it is called two or more times in a row, each new call to add() inserts its argument between the last object added to the list and the one that will be returned by the next call to next(). One consequence of this definition is that executing add() doesn t change the result of future calls to next() or hasnext(). Example: Suppose the list L contains the following strings: rat cow we execute the following sequence of statements: monkey. If Iterator iter = L.iterator(); Object first = iter.next(); iter.add( cat ); iter.add( dog ); // sets first to rat then the resulting list is rat cat dog cow monkey, and the next time next() is called it will return cow, as it would have done even if nothing had been added. End of example. If add() is called after the iterator is created but before the first call to next(), then the new object is added at the beginning of the list. Similarly, if add() is called after next() has returned the last item in the original list (i.e., when hasnext()==false), then the new object is added to the end of the list and hasnext() still returns false if it is called. The code for the doubly-linked list nodes and the SimpleLinkedListIterator class is given below and on the next page. Complete the definition of method add() on the page after that. This code taken directly from the sample solution to midterm 2, with only one difference: method remove() and associated variables are not included, since they are not relevant for this question. Feel free to tear out these pages for reference. public class DLink { public Object item; public DLink next; public DLink prev; // one node in a double-linked list // data associated with this link // next link in the list; null if none // previous link; null if none /** Construct a new node referring to the given object */ public DLink(Object item, DLink next, DLink prev) {...

8 CSE 143 Sp03 Final Exam Sample Solution Page 8 of 13 /** A simple List class */ public class SimpleLinkedList { // instance variables private DLink first; // first item in the list, or // null if the list is empty private DLink last; // last item in the list, or // null if the list is empty... other methods and constructors omitted... /** Iterator for SimpleLinkedList class (nested class) */ private class SimpleLinkedListIterator implements Iterator { // instance variables private DLink nextlink; /** Construct a new iterator */ public SimpleLinkedListIterator() { nextlink = first; // link to next object to be // returned by this iterator, or // null if all objects returned /** Return true if this iterator has more elements */ public boolean hasnext() { return (nextlink!= null); /** Return the next element in the iteration NoSuchElementException if the iteration has * no more elements */ public Object next() throws NoSuchElementException { if (!hasnext()) { throw new NoSuchElementException(); // get next element, advance, and return its value Object result = nextlink.item; nextlink = nextlink.next; return result;... (continued next page)

9 CSE 143 Sp03 Final Exam Sample Solution Page 9 of 13 Question 8. (concluded) Complete the definition of method add() below. For full credit, you may not change the implementation of the existing methods, and you must use the linked list and iterator data structures and instance variables as defined on the previous pages. You may, of course, add additional instance variables or methods if you need them to implement add(). Hint: Draw some pictures to visualize the situation before/while writing code. // Declare any additional instance variables you need here // nothing needed /** Add the given object to the list between the last object * returned by next() and the next object that will be * returned by next(). obj The object to be added. */ public void add(object obj) { // there are three cases to consider: // - adding a new link at the beginning of the list // (two subcases: adding a link to an empty list // and adding a link before the original first link) // - adding a new link at the end of the list, which // occurs if hasnext() returns false (nextlink==null) // - adding a link somewhere in the middle (general case) if (first == nextlink) { // new link at the beginning of the list DLink p = new DLink(obj, first, null); if (first == null) { last = p; else { first.prev = p; first = p; else if (nextlink == null) { // new link at the end of the list; list not empty DLink p = new DLink(obj, null, last); last.next = p; last = p; else { // general case add in middle. We know that // nextlink!= null and nextlink.prev!= null. DLink p = new DLink(obj, nextlink, nextlink.prev); nextlink.prev.next = p; nextlink.prev = p; // end of method add // end of SimpleLinkedListIterator class // end of SimpleLinkedList class

10 CSE 143 Sp03 Final Exam Sample Solution Page 10 of 13 The next two questions concern Binary Search Trees containing integer values in their nodes. The nodes are defined by the following Java class. public class IntBSTNode { // one node an integer BST public int value; // data associated with this node public IntBSTNode left; // left subtree; null if empty public IntBSTNode right; // right subtree; null if empty // no constructor, since we don t need it Question 9. (7 points) The height of a binary tree is defined to be 0 for an empty tree, 1 for a tree consisting of a single node, 2 for a tree consisting of a root node with one or two children that are leaf nodes, etc. Complete the definition of method height() below so it returns the height of the tree whose root is given as its argument. (Hint: recursion is your friend.) // return the height of the binary search tree with root r public int height(intbstnode r) { if (r == null) { return 0; else { int leftheight = height(r.left); int rightheight = height(r.right); if (leftheight >= rightheight) { return leftheight + 1; else { return rightheight + 1; A more compact solution: // return the height of the binary search tree with root r public int height(intbstnode r) { if (r == null) { return 0; else { return 1 + Math.max(height(r.left), height(r.right)); (Notice that neither solution actually uses the fact that the binary tree is a binary search tree. The code works equally well for an arbitrary binary tree.)

11 CSE 143 Sp03 Final Exam Sample Solution Page 11 of 13 (IntBSTNode definition repeated here to reduce the need for page flipping.) public class IntBSTNode { // one node an integer BST public int value; // data associated with this node public IntBSTNode left; // left subtree; null if empty public IntBSTNode right; // right subtree; null if empty // no constructor Question 10. (6 points) Complete the definition of method max() below so it returns the largest value stored in any node in the tree. You should assume that the initial tree in the first call to max has at least one node, but you may not make any other assumptions about the number of nodes in the tree or the values stored in them. For full credit, your method must not visit any more nodes in the tree than are actually necessary (Hint: recursion may be your friend.) // return the largest value in the binary search tree // with root r public int max(intbstnode r) { // precondition: r!= null (true initially because we can // assume that the original tree is not empty, and we will // not call max recursively for an empty tree) if (r.right == null) { // rightmost node; its value is the max value return r.value; else { // not a leaf get max of non-empty right subtree return max(r.right); This can also be done cleanly with a simple loop that chases down the right subtrees until it finds the rightmost node. public int max(intbstnode r) { // precondition: r!= null while (r.right!= null) { r = r.right; return r.value; (Solutions that returned the correct answer but visited more nodes than necessary received partial credit.)

12 CSE 143 Sp03 Final Exam Sample Solution Page 12 of 13 Question 11. (10 points) Parsing. (Yup, you knew it was coming, didn t you?) The expression/term/factor grammar, as extended for Project 3, handled expressions containing addition, subtraction, multiplication, and division. One possible implementation of the corresponding parser would be to have each parser method return the value of the expression or sub-expression that it parses. Here is a summary of the grammar and the methods of the parser. (The grammar only includes integer constants, no variables). expression ::= expression + term expression term term term ::= term * factor term / factor factor factor ::= integerconstant ( expression ) /** Parser to return the value of simple arithmetic expressions */ public class Parser {... tokenizer and delimiters omitted to save space... // parser state private String nexttoken; // next token from input to be // parsed, or (0-length // string) if no input remains // advance nexttoken to next token in the input private void advance() {... // parser methods // Parse expression ::= term {+- term... // and return the value of the expression that was parsed private int expression() {... // Parse term ::= factor {*/ factor... // and return the value of the term that was parsed private int term() {... // Parse factor ::= integerconstant ( expression ) // and return the value of the factor that was parsed private int factor() {... For this question, we want to modify the grammar and the parser to support exponentiation with the correct precedence and associativity. The syntax x^y means x raised to the y power. Exponentiation is a binary operation like +-*/, with one difference: it is rightassociative, not left-associative, unlike the other binary operations. In other words, x^y^z means x^(y^z), not (x^y)^z. Implementation detail: to calculate z = x^y in Java, use the Math.pow function and cast the result of Math.pow from double to int, e.g., int z = (int)math.pow(x,y);. (continued next page)

13 CSE 143 Sp03 Final Exam Sample Solution Page 13 of 13 Question 11. (cont) Here is the expression grammar modified to include exponentiation with the correct precedence (higher than * and /) and associativity (right associative). expression ::= expression + term expression term term term ::= term * power term / power power power ::= factor ^ power factor factor ::= integerconstant ( expression ) (a) (3 points) Assuming that we introduce a method power() to parse the grammar rule for power and return the value of the power that was parsed, what change(s) are needed to the existing parser methods for expression, term, and factor so they will work correctly with power() to handle arithmetic expressions that include exponentiation? (Just describe the changes that would be needed, you don t need to give an implementation.) The only changes that would be needed are in method term(), where all calls to method factor() should be replaced by calls to power(). (b) (7 points) Complete the implementation of method power() so it will correctly parse exponentiation and return the value of the power sub-expression it has parsed. (Hint: think about how you want to handle x ^ y ^ z ^.... A simple iteration might or might not produce the right result.) // Parse power ::= factor {^ factor... // (i.e., power ::= factor factor ^ power) // and return the value of the power that was parsed private int power() { int left = factor(); if (nexttoken.equals("^")) { advance(); int right = power(); return (int)math.pow(left, right); else { return left; (The difference between this method and the ones for expression/term/factor is that we need to ensure that ^ is treated as a right associative operator. So instead of a loop that parses the subexpressions to the right of ^ one at a time using individual calls to factor(), we call power() recursively to parse and return the value of all of the remaining exponential operators to the right.)