Test 2: CPS 100. Owen Astrachan. November 10, 2004

Transcription

1 Test 2: CPS 100 Owen Astrachan November 10, 2004 Name: Login: Honor code acknowledgment (signature) Problem 1 value 22 pts. grade Problem 2 20 pts. Problem 3 22 pts. TOTAL: 64 pts. This test has 14 pages, be sure your test has them all. Do NOT spend too much time on one question remember that this class lasts 75 minutes. In writing code you do not need to worry about specifying the proper import statements. Assume that all libraries and packages we ve discussed are imported in any code you write. 1

2 Some common recurrences and their solutions. The class TreeNode used on this test. A T(n) = T(n/2) + O(1) O(log n) B T(n) = T(n/2) + O(n) O(n) C T(n) = 2T(n/2) + O(1) O(n) D T(n) = 2T(n/2) + O(n) O(n log n) E T(n) = T(n-1) + O(1) O(n) F T(n) = T(n-1) + O(n) O(n 2 ) G T(n) = 2T(n-1) + O(1) O(2 n ) public static class TreeNode { String info; TreeNode left; TreeNode right; TreeNode(String val, TreeNode lptr, TreeNode rptr) { info = val; left = lptr; right = rptr; 2

3 PROBLEM 1 : (Simple Stuff (22 points)) "koala" "grizzly" "polar" "brown" "panda" "teddy" "kodiak" Part A (3 points) What is the preorder traversal of the search tree above whose root is "koala"? Part B (3 points) The height of a tree is the number of edges on the longest root-to-leaf path, the height of the bear tree above is three. Draw another search tree with the same values, but whose height is two (you may need a different bear at the root of the new tree you draw). 3

4 Part C (4 points) The method count below returns the number of nodes in a tree. public static int count(treenode t){ if (t == null) return 0; return 1 + count(t.left) + count(t.right); The depth of a node is the number of edges from the root to the node. In the bear tree above "panda", "teddy", and "brown" have depth two; "kodiak" has depth three. Write the method depthcount that returns the number of nodes with the specified depth. The root of a tree has depth zero. * Returns number of nodes at specified depth in Tree t. public static int depthcount(treenode t, int depth){ 4

5 Part D (4 points) Write the method twochildcount that returns the number of nodes that have two children in a tree. For the tree above the method should return two since only "polar" and "koala" have two children. * Returns number of nodes with two children in t. public static int twochildcount(treenode t){ 5

6 Part E (4 points) The method longest below returns the length of the longest string in a tree. What is the big-oh complexity of this method and why (Justify your answer). * Return length of longest string in tree with given root. public static int longest(treenode root){ if (root == null) return 0; return Math.max(root.info.length(), Math.max(longest(root.left), longest(root.right))); Part F (4 points) The method reverse below reverses the links in a linked list so that the list shown on the left is changed to the list on the right by re-arranging links as a result of executing list = reverse(list). (ape, gorilla, monkey, orangutan) (orangutan, monkey, gorilla, ape) What is the complexity of reverse? Justify your answer. public static class Node{ String info; Node next; Node(String val, Node link){ info = val; next = link; public static Node reverse(node n){ if (n == null n.next == null) return n; // no nodes or 1, done Node afterme = reverse(n.next); // reverse rest // now find end of reversed list and link to me Node temp = afterme; while (temp.next!= null){ temp = temp.next; temp.next = n; n.next = null; return afterme; 6

7 PROBLEM 2 : (Trees and Lists oh My (20 points)) In this problem you ll write methods to convert a sorted ArrayList to a balanced binary search tree containing the same values stored in the ArrayList, and vice versa: a method to convert a tree to a sorted list. The picture below shows one example of a list and the tree that corresponds to the list. (the tree shows numbers, but Strings are stored in the tree, see the declarations at the beginning of this test) Part A (5 points) The method tree2list returns a sorted ArrayList containing the same values as the tree passed to the method. The general algorithm for the helper method tree2listaux is to perform an inorder traversal of the tree, adding a tree value to the list when the tree node is visited during the traversal. Since the inorder traversal of a search tree visits nodes in sorted order, the resulting list will be sorted. Complete the method tree2listaux, you should not write more than four statements and you may not modify the code in tree2list. * Return sorted list containing same values stored in search tree t. t is a search tree sorted list containing same values in t public static ArrayList tree2list(treenode t){ ArrayList list = new ArrayList(); tree2listaux(t,list); return list; * Add values of tree to list in sorted order. list stores values (in order) already visited root is the root of the (sub) tree to be added to list private static void tree2listaux(treenode root, ArrayList list){ if (root!= null){ 7

8 Part B (5 points) The general algorithm for converting a list to a tree is: Find the root of the tree, which is the middle element of the list. Make a node for the root, and recursively make left and right subtrees. The method list2tree calls a helper method that does the work, the helper method has parameters indicating the range in the list that is converted to a tree. Complete list2treeaux so that it works as specified. * Returns balanced tree from sorted list. list is sorted balanced search tree containing same values in list public static TreeNode list2tree(arraylist list){ return list2treeaux(list,0,list.size()-1); * Return balanced tree consisting of values in list in range * list[first]..list[last], including first and last, where list * is sorted. Returns null if first > last. list is sorted first is first index of list to be put into tree last is last index of list to be put into tree balanced tree containing values list[first]..list[last] private static TreeNode list2treeaux(arraylist list, int first, int last){ if (first > last) return null; int mid = (first + last)/2; String rootvalue = (String) list.get(mid); // add code here 8

9 Part C (3 points) Write a recurrence relation for the code you wrote for Part A. Justify the recurrence and indicate what its big-oh solution is. Part D (3 points) Write a recurrence relation for the code you wrote for Part B. Justify the recurrence. (If you wrote the simplest code for Part B the solution should be O(n) for an n-element array.) Part E (4 points) Suppose you want to convert a sorted linked-list into a search tree. Using the algorithm for Part B above yields an O(n log n) solution because finding the middle element takes O(n) time. Explain why this results in an O(n log n) algorithm and explain how to do the conversion in O(n) time by first creating an array from the linked list. 9

10 PROBLEM 3 : (Mercator Projection (22 points)) The code handout at the end of this test shows a main that reads a file and creates a map in which keys are the words in the file and the value corresponding to a key is a Counter that indicates how many time the word occurs in the file. Part of the code is reproduced below. Part A (4 points) Scanner s = new Scanner(f); Map m = new TreeMap(); while (s.hasnext()){ String str = (String) s.next(); Counter c = (Counter) m.get(str); if (c == null){ m.put(str, new Counter()); else { c.increment(); Complete the code fragment below so that it correctly stores in smax the word that occurs most frequently, and stores the number of occurrences of this word in max. int max = 0; String smax = null; // most frequent occurrences // most frequently occurring word Iterator it = m.keyset().iterator(); while (it.hasnext()){ String str = (String) it.next(); System.out.println("most frequent "+smax + " "+max); 10

11 Three methods are shown in the code at the end of the test: topthirty1, topthirty2, and topthirty3. Each does the same thing: returns an array of the 30 most-frequently occurring words in order so that the first element in the returned array is the most frequently occurring word, the second element in the array is the second most frequently occurring word, and so on. Each of the three methods works correctly. You ll be asked questions about each method which are reproduced below. Part B (6 points) Recall that the class Map.Entry stores both the key and the corresponding value of an entry in a map; both the key and the value can be obtained as shown in the code below. Explain in words why the method topthirty1 returns an array with the most frequently occurring word in the map stored at index 0 of the array, the second most frequently occurring word stored at index 1, and so on. You should mention how the Comparator works in the code. private static class EntryComparator implements Comparator{ public int compare(object o1, Object o2) { Map.Entry me1 = (Map.Entry) o1; Map.Entry me2 = (Map.Entry) o2; Counter c1 = (Counter) me1.getvalue(); Counter c2 = (Counter) me2.getvalue(); return c2.getvalue() - c1.getvalue(); public static String[] topthirty1(map m){ ArrayList list = new ArrayList(m.entrySet()); Collections.sort(list, new EntryComparator()); String[] a = new String[30]; for(int k=0; k < 30; k++){ Map.Entry entry = (Map.Entry) list.get(k); a[k] = (String)entry.getKey(); return a; 11

12 Part C (6 points) The method topthirty2 below uses a PriorityQueue to obtain the 30 most frequently occurring words in a map. Explain in words why the EntryComparator is needed when creating the priority queue and what the big-oh complexity of the method below is for finding the top 30 words in a map with N elements. Justify your answer. public static String[] topthirty2(map m){ PriorityQueue pq = new PriorityQueue(new EntryComparator()); pq.addall(m.entryset()); String[] list = new String[30]; for(int k=0; k < 30; k++){ Map.Entry entry = (Map.Entry) pq.remove(); list[k] = (String)entry.getKey(); return list; 12

13 Part D (6 points) The code below also uses a PriorityQueue, but never stores more than 30 elements in the queue. Explain three things: (A) why the class RevComp is used in the code; (B) why the index 30-k-1 is used in the statement below list[30-k-1] = (String) entry.getkey(); instead of using list[k]; and (C) why this method is more efficient than the other two methods. Justify your answers. private static class RevComp implements Comparator{ Comparator mycomp; public RevComp(Comparator c){ mycomp = c; public int compare(object o1, Object o2){ return -1*myComp.compare(o1,o2); public static String[] topthirty3(map m){ PriorityQueue pq = new PriorityQueue(new RevComp(new EntryComparator())); Iterator it = m.entryset().iterator(); while (it.hasnext()){ pq.add(it.next()); if (pq.size() > 30){ pq.remove(); String[] list = new String[30]; for(int k=0; k < 30; k++){ Map.Entry entry = (Map.Entry) pq.remove(); list[30-k-1] = (String) entry.getkey(); return list; 13

14 nothing on this page 14

15 import java.io.file; import java.util.*; import javax.swing.jfilechooser; class Counter { Nov 10, 04 1:24 Test2.java Page 1/3 private int mycount; * Construct a counter whose value is zero public Counter() { this(1); public Counter(int value) { mycount = value; * Returns the value of the counter. the value of the counter public int getvalue() { return mycount; * Zeros the counter so getvalue() == 0. public void clear() { mycount = 0; * Increase the value of the counter by one. public void increment() { mycount++; * Return a string representing the value of this counter. public String tostring(){ return ""+mycount; public class Test2 { private static JFileChooser ourchooser = new JFileChooser("."); private static class TreeNode { String info; TreeNode left; TreeNode right; TreeNode(String val, TreeNode lptr, TreeNode rptr) { info = val; left = lptr; right = rptr; private static class EntryComparator implements Comparator{ ); Map.Entry me2 = (Map.Entry) o2; Counter c1 = (Counter) me1.getvalue(); Counter c2 = (Counter) me2.getvalue(); return c2.getvalue() c1.getvalue(); private static class RevComp implements Comparator{ Comparator mycomp; public RevComp(Comparator c){ mycomp = c; public int compare(object o1, Object o2){ return 1*myComp.compare(o1,o2); public static String[] topthirty2(map m){ PriorityQueue pq = new PriorityQueue(new EntryComparator()); pq.addall(m.entryset()); String[] list = new String[30]; for(int k=0; k < 30; k++){ Map.Entry entry = (Map.Entry) pq.remove(); list[k] = (String)entry.getKey(); return list; public static String[] topthirty3(map m){ PriorityQueue pq = new PriorityQueue(new RevComp(new EntryComparator()) Iterator it = m.entryset().iterator(); while (it.hasnext()){ pq.add(it.next()); if (pq.size() > 30){ pq.remove(); String[] list = new String[30]; for(int k=0; k < 30; k++){ Map.Entry entry = (Map.Entry) pq.remove(); list[30 k 1] = (String)entry.getKey(); return list; public static String[] topthirty1(map m){ ArrayList list = new ArrayList(m.entrySet()); Collections.sort(list, new EntryComparator()); String[] a = new String[30]; for(int k=0; k < 30; k++){ Map.Entry entry = (Map.Entry) list.get(k); a[k] = (String)entry.getKey(); return a; Printed by Owen L. Astrachan Nov 10, 04 1:24 Test2.java Page 2/3 public int compare(object o1, Object o2) { Map.Entry me1 = (Map.Entry) o1; Wednesday November 10, 2004 Test2.java 1/2

16 Nov 10, 04 1:24 Test2.java Page 3/3 Printed by Owen L. Astrachan public static void main(string[] args){ int retval = ourchooser.showopendialog(null); if (retval == JFileChooser.APPROVE_OPTION){ File f = ourchooser.getselectedfile(); Scanner s = new Scanner(f); Map m = new TreeMap(); while (s.hasnext()){ String str = (String) s.next(); Counter c = (Counter) m.get(str); if (c == null){ m.put(str, new Counter()); else { c.increment(); String[] list1 = topthirty1(m); String[] list2 = topthirty2(m); String[] list3 = topthirty3(m); Wednesday November 10, 2004 Test2.java 2/2