Compsci 201 Priority Queues & Autocomplete Owen Astrachan Jeff Forbes November 10, 2017 11/10/17 Compsci 201, Fall 2017, Searching

T is for … TeraFLOPS Xbox One X @ 6 x1012 operations per second Turing award Award for highest distinction in CS – 2016 Tree More versions to come Trie O(#characters) search 11/10/17 CompSci 201, Fall 2017, Search

Plan for the Day Introduce data structures and algorithms for search Heaps for Priority Queues Towards Autocomplete 11/10/17 CompSci 201, Fall 2017, Search

What’s in Common? 11/10/17 CompSci 201, Fall 2017, Search

Priority! Applications of Priority Queues Shortest Path: Google Maps to Internet Routing Event based simulation: Predicting collisions Best-first search, game-playing, AI Java code below sorts list. How? Why?

How are PriorityQueues implemented? Heap is an array-based implementation of a binary tree used for implementing priority queues, supports: insert, findMin, deleteMin: complexities? Using array minimizes storage (no explicit pointers), faster too --- children are located by index/position in array Heap is a binary tree with shape property, heap/value property shape: tree filled at all levels (except perhaps last) and filled left-to-right (complete binary tree) value: each node has value smaller than both children

Using an array for a Heap Store “node values” in array beginning at index 1 Could also store starting at index 0 For node with index k left child: index 2*k right child: index 2*k+1 parent: index k/2 Why is this structure conducive for maintaining heap shape? What about value property? Is the heap a search tree? Where is minimal node? 1 2 3 4 5 6 7 8 9 10 17 13 25 21 19 6 10 7 17 13 9 21 19 25

Heap questions Where is minimal element? Root, why? Where is maximal element? http://bit.ly/201f17-heaps-0 What is complexity of find max in a min-heap? Why? Where is second smallest element? Why? 6 10 7 17 13 9 21 19 25 1 2 3 4 5 6 7 8 9 10 17 13 25 21 19 http://bit.ly/201f17-heaps-1

Adding values to heap To maintain heap shape, must add new value in left-to-right order of last level could violate heap property move value “up” if too small Change places with parent if heap property violated stop when parent is smaller stop when root is reached Pull parent down, swapping isn’t necessary (optimization) 13 6 10 7 17 9 21 19 25 insert 8 13 6 10 7 17 9 21 19 25 8 6 10 7 17 9 21 19 25 13 8 bubble 8 up 6 7 17 9 21 19 25 8 13 10 http://bit.ly/201f17-heaps-2

Heap add implementation 13 6 10 7 17 9 21 19 25 13 6 10 7 17 9 21 19 25 8 1 2 3 4 5 6 7 8 9 10 17 13 25 21 19 ArrayList<Integer> list

Removing extremal element Where is minimal element? If we remove it, what changes, shape/property? How can we maintain shape? “last” element moves to root What property is violated? After moving last element, subtrees of root are heaps, why? Move root down (pull child up) does it matter where? When can we stop “re-heaping”? Less than both children Reach a leaf 13 6 10 7 17 9 21 19 25 13 25 10 7 17 9 21 19 13 7 10 25 17 9 21 19 13 7 10 9 17 25 21 19

Priority Queue implementations Implementing priority queues: average and worst case Insert average Getmin (peek) worst (delete) Unsorted ArrayList O(1) O(n) Sorted ArrayList O(1)/ O(n) Heap O(log n) Balanced binary search tree O(log n)/ O(1) Heap has O(1) find-min (no delete) and O(n) build heap

Problem 1 Big Oh if PriorityQueue implemented with Heap? Keep track of top M of N elements (N >> M). Big Oh if PriorityQueue implemented with Heap?

Problem 2 Determine the number of elements < target in heap lessCount(heap,13) → 3 lessCount(heap,8) → 1 O(k) where k is #of elements less than target What is you had helper method that returns # elements in subheap rooted/starting at index that are less than target? int lessCount(int[] heap, int index, int target) What’s the initial call to helper method? http://bit.ly/201f17-heaps-3 11/10/17 CompSci 201, Fall 2017, Search

What is autocomplete? As user types in search box Give potential completions. How? Efficiency is key 50 ms or go home Data (Terms) Possible words/phrases Weights

Searching public interface Autocompletor { // Returns the top k matching terms in descending order of weight. public Iterable<String> topMatches(String prefix, int k); // Returns the single top matching term public String topMatch(String prefix); // Return the weight of a given term public double weightOf(String term); }

The Term class The Term class encapsulates a Comparable word-weight pair. Includes completed compareTo method, which sorts lexicographically. You are responsible for implementing three Term Comparators: WeightOrder, which sorts in ascending weight order ReverseWeightOrder, which sorts in descending weight order PrefixOrder, which sorts by the first r characters

Comparable and Comparator Both are interfaces, there is no default implementation Contrast with .equals(), default implementation? Contrast with .toString(), default? Where do we define a Comparator? In its own .java file, nothing wrong with that Private, used for implementation and not public behavior Use a nested class, then decide on static or non-static Non-static is part of an object, access inner fields In Term class: once written initialize with new Term.ReverseWeightOrder(); or new Term.PrefixOrder(2);

Comparator’s compare x ≤ y takes two Objects (of the same class) as arguments Returns a negative value if the 1st is less than 2nd zero if the arguments are equal, and a positive value if the 1st is greater than the 2nd compare will be called by methods in Arrays.sort or PriorityQueue? Why? x ≤ y is equivalent to compare(x,y) <= 0

PrefixOrder The goal of PrefixOrder is to sort lexicographically, but only considering the first r characters. e.g. normally we would put “energy” before “entropy” lexicographically. However, PrefixOrder with r = 2 considers them equal (PrefixOrder with r = 3 would still put “energy” before “entropy”, however). If one or both of the words is shorter than r characters, we just use normal lexicographic sorting. For full credit, PrefixOrder’s compare method should take O(r).

BruteAutocomplete Naïve approach to autocomplete Store data as a Term array. Find the top k matches: iterates through the array, pushes all terms starting with the prefix onto a max-priority queue sorted by weight. Return top k terms off that priority queue Find top match is similar

Why is BruteAutocomplete bad? If we have n terms, m of which start with the prefix, then topKmatches is O(n + m log m) and topMatch is O(n). Why is this bad? Imagine Google! So, we wish to improve upon BruteAutocomplete, by only considering those terms that start with prefix

Improving BruteAutocomplete BruteAutocomplete had to iterate through every single term in the array because it did not have any prior knowledge as to where terms starting with the prefix could be located – i.e. the array was unsorted. If we sort the array lexicographically, then all terms which start with the prefix will be adjacent. Sorting takes O(n log n), but we only have to do it once every call to topMatch or topKMatches, regardless of inputs, can use the same sorted Term array. Need to locate terms starting with the prefix quickly. Use binary search.

Binary Search Search for 5? Where to go? How to reduce problem size?

Binary Search How did problem change?

Binary Search

BinarySearchAutocomplete For Autocomplete: find the range of all terms comparator considers equal to key e.g., all terms with a that match prefix auto BinarySearchAutocomplete is the 2nd class you should implement. BinarySearchAutocomplete implements Autocompletor plus: public static int firstIndexOf(Term[] a, Term key, Comparator<Term> comp) public static int lastIndexOf(Term[] a, Term key, Comparator<Term> comp) Use binary search to quickly return the first and last index respectively of an element in the input array which the comparator considers equal to key. We specify first and last index because there could be multiple Terms in a which the comparator considers equal to key.

Binary search code

Modifications for BinarySearchAutocomplete