APCS :: Winter Quarter Exam Review Packet

Transcription

1 APCS :: Winter Quarter Exam Review Packet O(n 2 ) Sorting algorithms. You should be able to derive the code for any of the three O(n 2 ) sorting algorithms in the following manner: 1. Assume you have the following method available to use: // swap method will swap the values at two given indices // within the ArrayList // Pre-Condition: param from and to are valid indices in A public void swap(arraylist<comparable> A, int from, int to) Write one of the following O(n 2 ) sorting algorithms. // I only give one here public void insertionsort(arraylist<comparable> A) for(int i=1; i<a.size(); i++) for(int j=i; j>=1; j--) if(a.get(j).compareto(a.get(j-1)<0) swap(a, j, j-1); else j = 0; //force inner-loop to quit public void selectionsort(arraylist<comparable> A) public void bubblesort(arraylist<comparable> A) 2. Given the starting array shown below fill in the empty arrays showing what the array looks like after each pass of the outer for-loop for the algorithm you wrote above: step Baker Franke 2007 APCS - 3/9/07 :: 1 of 8

2 O(n*lg n) Sorting Algorithms When writing recursive algorithms don t forget to consider the stopping case. 1. Assume you have the following methods at your disposal: public ArrayList<Comparable> split(arraylist<comparable> A, int from, int to) public ArrayList<Comparable> merge(arraylist<comparable> A, ArrayList<Comparable> B) Write the mergesort method which is declared for you below: public ArrayList<Comparable> mergesort(arraylist<comparable> A) if(a.size()==1) return A; ArrayList<Comparable> left = split(a, 0, A.size()/2); ArrayList<Comparable> right = split(a, A.size()/2, A.size()-1); left = mergesort(left); right = mergesort(right); return merge(left, right); 2. Draw a picture of Mergesort in action. Start with an array of 8 comparable elements and render each step of mergesort both on the way down and on the way up. <<split on the way down>> << merge on the way up>> Assume you have the following method at your disposal: // will partition A around some element in the range between Baker Franke 2007 APCS - 3/9/07 :: 2 of 8

3 // low and high, inclusive. It returns the index where the // partitioning element ended up. // The partitioning algorithm used should not be considered // at this time. public int partition(arraylist<comparable> A, int from, int to) Write the quicksort method which is started for you below: //performs quicksort on A between indices from and to, inclusive. public void quicksort(arraylist<comparable> A, int from, int to) if(from>=to) return; int p = partition(a, from, to); quicksort(a, from, p-1); quicksort(a, p+1, to); 4. Draw a picture of Quicksort in action. Start with an array of 8 comparable elements and render each step of quicksort in an illustrative way. << always choose first element of each section as partition element>> (Underlined values are ones in their final placement after partitioning.) Explain why mergesort has BEST and WORST case running time of O(n*lg n). Because the same process of splitting and merging happens no matter what order the array starts out in. 6. What is the worst case running time for Quicksort? Why? Worst case is O(n 2 ) if the partitioning element is chosen unwisely. For example, if the array is in order to begin with, and the partitioning element is chosen as the first element of each chunk to be sorted, the algorithm won t benefit from divide-and-conquer because it will recur on only one fewer element each step. This can be fixed by partitioning in such a way as to gauruntee worst-case behavior won t occur. i.e. for chunks larger than say 5 elements, choose to partition around the median of 3 random elements within the chunk. Baker Franke 2007 APCS - 3/9/07 :: 3 of 8

4 Comparators: 1. Consider a Person class that has the following public methods: String name() int age() int ssn() Write a Comparator for Person objects such that Person A is less than Person B if: A s name comes before B s name in dictionary order If the names are equivalent, A s age is greater than B s age If name and age are equivalent, A s ssn is less than B s ssn public class PersonComp extends Comparator<Person> public int compare(person A, Person B) int namecomp = A.getName().compareTo(A.getName()); if(namecomp!=0) return namecomp int agecomp = B.age() - A.age() ; //negative if A is older if(agecomp!=0) return agecomp; int ssncomp = A.ssn()-B.ssn(); // negative if A s ssn is less return ssncomp; 2. Assume you have a PersonComparator that comares Person objects the way you want. Write the sort method below using a PriorityQueue (java.util) to sort the Person objects in the given ArrayList: You may only use a PriorityQueue and the PersonComparator to do the sorting - no other data structures. The sorting should appear to happen in-place. // an in-place sort of A using compartor C. public void sort(arraylist<person> A, PersonComparator C) PriorityQueue<Person> PQ = new PriorityQueue<Person>(10, C); while(a.size()>0) PQ.add(A.remove(0)); while(pq.size()>0) A.add(PQ.remove()); 3. What is the Big-Oh Running time of the sort method described in 2? (This question can be answered regardless of whether you ve written an answer for 2 or not). The Big-Oh running time can be derived: O(n) for n removals from the ArrayList +O(n*lg n) for the n additions to the PQ + O(n*lg n) for the n removals from the PQ + O(n) for the n additions to the ArrayList Baker Franke 2007 APCS - 3/9/07 :: 4 of 8

5 = O(2n + 2(n*lg n) ) = O(n* lg n) Heaps: 1. Explain the rules of a Heap. Draw a picture of a valid Heap with 10 elements in it. A heap is a full binary tree where each node in the tree is less than or equal to both of its two children Write a recursive bubbleup method for a heap. Assume the heap stores the root at index 1 in the ArrayList. Read the comments for clues about how to write it. public class Heap private ArrayList<Comparable> myheap; // assume myheap is initialized properly by the constructor. // bubble up the value stored in index. // if index is the root, can t bubble up. // otherwise compare the element at index with its parent // and swap if necessary // then continue to bubble up as necessary. // Pre-condition: index < myheap.size() public int bubbleup(int index) if(index > 1 && myheap.get(index).compareto(myheap.get(index/2))<0) swap(a, index, index/2); bubbleup(index/2); else return index; Binary Tree Remember: A Binary Tree is not a Binary Search Tree, nor is it a heap. A Binary Tree is simply a tree where each node has at most two children. 1. Write a find method for an unordered binary tree. The method should traverse the tree looking for the value. // returns true if tofind is found somewhere in the tree, otherwise false. public boolean find(treenode t, Object tofind) if(t==null) return false; Baker Franke 2007 APCS - 3/9/07 :: 5 of 8

6 int compval = ((Comparable)toFind).compareTo(t.getValue()); if(compval==0) return true; else if(compval < 0) return find(t.getlef(), tofind); else return find(t.getright(), tofind); Binary Search Trees 0. You should feel comfortable about the basic BST methods we wrote in class (source code available on the website) add, find, traverse. 1. Write a recursive method to check that a binary tree is in proper binary search tree order. A Binary Search Tree is in proper order if, for some node n, it s value is greater than or equal to the value of its left child, and less than its right child, AND its left an right subtrees are in proper order. If a node has no children it is trivially in proper order. The method is started for you below (Careful! null pointer exceptions lurk in the shadows): public boolean confirmorder(treenode t) if(t==null) return true; // assume it s in order, set boolean to false if find it s not boolean nodeinorder = true; if(t.getleft()!=null && t.getleft().getvalue().compareto(t.getvalue())>0) nodeinorder = false; if(t.getright()!=null && t.getright().getvalue().compareto(t.getvalue())<0) nodeinorder = false; return nodeinorder && confirmorder(t.getleft()) && confirmorder(t.getright()); 2. Write a recursive method to find the height of a given node. A null node has a height of 0. Otherwise a node s height is given by: 1 + max of the heights of its left and right subtrees. public int height(treenode t) Baker Franke 2007 APCS - 3/9/07 :: 6 of 8

7 if(t==null) return 0; //or 1 depending on def. of height return 1 + Math.max( height(t.getleft()), height(t.getright() ); 3. Write a recursive method that determines whether a given node is in balance. A node is in balance if the heights of its two subtrees differ by at most 1. You may use the height method written in 2 to aid your cause. The method is started for you below: public boolean isbalanced(treenode t) int heightdiff = Math.abs(height(t.getLeft()) height(t.getright())); return heightdiff <= 1; 4. Write a method that finds the max node in a tree. The max node is the right-most node in a tree. public TreeNode maxnode(treenode t) TreeNode temp = t; while(temp.getright()!=null) temp = temp.getright(); return temp; ********* recursive version ********** if(t.getright()==null) return t; else return maxnode(t.getright()); 5. Write a method toarraylist which traverse a BST and returns an in-order ArrayList of all the values contained in the tree rooted at t. public void toarraylist(arraylist data, TreeNode t) if(t==null) return; toarraylist(data, t.getleft()); data.add(t.getvalue()); toarraylist(data, t.getright()); 6. Draw a picture of a valid Binary Search Tree that has at least 10 values. Then, choose a non-leaf node to remove, and redraw the tree having chosen a node to replace the one you removed. Then: 1.) Indicate how you chose the replacement node. 2.) Declare the Big-Oh running time of the removal operation you specified and drew. Baker Franke 2007 APCS - 3/9/07 :: 7 of 8

8 Big-Oh Stuff What are the Big-Oh running times of the methods shown below (you do not need to know what it does to derive the Big-Oh running time): 1. public void mystery(arraylist A) for(int i=0; i<a.size(); i++) for(int j=i; j<i+5; j++) A.set(i, A.get(i)+j); mystery method has a running time complexity of O(n). The inner for-loop is a red herring. It always runs exactly 5 times. Therefore it is unrelated to the size of the problem and is considered a constant factor. 2. public void mystery2(arraylist A) for(int i=0; i<a.size(); i++) for(int j=0; j<i/2; j++) A.set(i, A.get(i)+j); mystery2 has a running time complexity of O(n 2 ). The inner loop runs a number of times related to i. Therefore the inner-loop is related to the size of the problem so it must be considered as a multiplicative factor. 3. Below is (somewhat bizarre) strategy for calculating the sum of all the ints in an array of ints. First, state how the method works. Second, state its Big-Oh running time. public int sum(int[] list, int lo, int hi) if(lo>hi) return 0; if(lo==hi) return list[hi]; return sum(list, lo, hi/2) + sum(list, hi/2+1, hi); sum has a running time complexity of O(n). This one is tricky. The unreduced complexity could be stated as O(lg n + n). Clearly there are lg n levels to the recursion. But if you actually count the number of additions performed it s proportional to n. Baker Franke 2007 APCS - 3/9/07 :: 8 of 8