CS203 Lecture 15

Quick-Sort Quick-sort is a randomized sorting algorithm based on the divide-and-conquer paradigm: Divide: pick a random element x (called pivot) and partition S into L elements less than x E elements equal x G elements greater than x Recur: sort L and G Conquer: join L, E and G x x L G E x Quick-Sort

Partition We partition an input sequence as follows: We remove, in turn, each element y from S and We insert y into L, E or G, depending on the result of the comparison with the pivot x Each insertion and removal is at the beginning or at the end of a sequence, and hence takes O(1) time Thus, the partition step of quick-sort takes O(n) time Algorithm partition(S, p) Input sequence S, position p of pivot Output subsequences L, E, G of the elements of S less than, equal to, or greater than the pivot, resp. L, E, G  empty sequences x  S.remove(p) while S.isEmpty() y  S.remove(S.first()) if y < x L.addLast(y) else if y = x E.addLast(y) else { y > x } G.addLast(y) return L, E, G Quick-Sort

Java Implementation Quick-Sort

Quick-Sort Tree An execution of quick-sort is depicted by a binary tree Each node represents a recursive call of quick-sort and stores Unsorted sequence before the execution and its pivot Sorted sequence at the end of the execution The root is the initial call The leaves are calls on subsequences of size 0 or 1 7 4 9 6 2  2 4 6 7 9 4 2  2 4 7 9  7 9 2  2 9  9 Quick-Sort

Worst-case Running Time The worst case for quick-sort occurs when the pivot is the unique minimum or maximum element One of L and G has size n - 1 and the other has size 0 The running time is proportional to the sum n + (n - 1) + … + 2 + 1 Thus, the worst-case running time of quick-sort is O(n2) dept h time n 1 n - 1 … … Quick-Sort

Expected Running Time Consider a recursive call of quick-sort on a sequence of size s Good call: the sizes of L and G are close to equal Bad call: one of L and G is much larger than the other 7 2 9 4 3 7 6 1 9 7 2 9 4 3 7 6 1 7 2 9 4 3 7 6 2 4 3 1 7 9 7 1  1 1 Good call Bad call 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 Bad pivots Good pivots Bad pivots Quick-Sort

Expected Running Time, Part 2 Best case: the pivots are all perfect. Height of tree is ceiling of O(log n) Typical case: some of the pivots are good, some are bad. Height still O(log n), with a different base Worst case: all the pivots are bad: height of tree is O(n) The amount or work done at the nodes of the same depth is O(n), because all the nodes appear at every depth Thus, the best case and expected running time of quick- sort is O(n log n); worst case is O(n2) Quick-Sort

In-Place Quick-Sort Quick-sort can be implemented to run in-place In the partition step, we use replace operations to rearrange the elements of the input sequence such that the elements less than the pivot have rank less than h the elements equal to the pivot have rank between h and k the elements greater than the pivot have rank greater than k The recursive calls consider elements with rank less than h elements with rank greater than k Algorithm inPlaceQuickSort(S, l, r) Input sequence S, ranks l and r Output sequence S with the elements of rank between l and r rearranged in increasing order if l  r return i  a random integer between l and r x  S.elemAtRank(i) (h, k)  inPlacePartition(x) inPlaceQuickSort(S, l, h - 1) inPlaceQuickSort(S, k + 1, r) Quick-Sort

In-Place Partitioning Perform the partition using two indices to split S into L and E U G (a similar method can split E U G into E and G). Repeat until j and k cross: Scan j to the right until finding an element > x. Scan k to the left until finding an element < x. Swap elements at indices j and k j k (pivot = 6) 3 2 5 1 0 7 3 5 9 2 7 9 8 9 7 6 9 j k 3 2 5 1 0 7 3 5 9 2 7 9 8 9 7 6 9 Quick-Sort

Java Implementation Quick-Sort

Merge Sort Merge Sort is a recursive divide and conquer algorithm 12 Merge Sort Merge Sort is a recursive divide and conquer algorithm Recursive method splits the list repeatedly until it is made up of single-element sublists, then merges them as the recursion unwinds: mergeSort(list): firstHalf = mergeSort(firstHalf); secondHalf = mergeSort(secondHalf); list = merge(firstHalf, secondHalf); merge: add the lesser of firstHalf [0] and secondHalf [0] to the new, larger list repeat until one of the (already sorted) sublists is exhausted add the rest of the remaining sublist to the larger list.

13 Merge Sort

Merge Sort Time 14 Thus, Merge Sort is O(n log n) Assume n is a power of 2. This assumption makes the math simpler. If n is not a power of 2, the difference is irrelevant to the order of complexity. Merge sort splits the list into two sublists, sorts the sublists using the same algorithm recursively, and then merges the sublists. Each recursive call merge sorts half the list, so the depth of the recursion is the number of times you need to split n to get lists of size 1, ie log n. The single-item lists are, obviously, sorted. Merge Sort reassembles the list in log n steps, just as it broke the list down. The total size of all the sublists is n, the original size of the unsorted list. To merge the sublists, across all the sublists at one level of recursion, takes at most n-1 comparisons and n copies of one element from a sublist to the merged list. The total merge time is 2n-1, which is O(n). The O(n) merging happens log n times as the full sorted array is built. Thus, Merge Sort is O(n log n)

15 Bucket Sort All sort algorithms discussed so far are general sorting algorithms that work for any types of keys (e.g., integers, strings, and any comparable objects). These algorithms sort the elements by comparing their keys. The lower bound for general sorting algorithms is O(n logn). So, no sorting algorithms based on comparisons can perform better than O(n log n). However, if the keys are small integers, you can use bucket sort without having to compare the keys.

16 Bucket Sort The bucket sort algorithm works as follows. Assume the keys are in the range from 0 to N-1. We need N buckets labeled 0, 1, ..., and N-1. If an element’s key is i, the element is put into the bucket i. Each bucket holds the elements with the same key value. You can use an ArrayList to implement a bucket. Bucket Sort is O(n). Searching: finding the bucket is O(1). Searching the list in one bucket is O(1) in the best case and O(n) in the worst case. Note the similarity to a hash map with a very simple hash function.

Strategy Pattern The Strategy pattern provides interchangeable algorithms for solving some problem by encapsulating them in objects. In Java, Strategy is implemented using a Java interface with multiple implementations. Each implementing class can use a different algorithm. A Strategy pattern can be set up so that the particular algorithm can be chosen at runtime based on characteristics of the actual data or other considerations. Arrays.sort() implements the Strategy pattern; it chooses the particular type of sort to use, and this is transparent to client code. An application that can save files in different file formats might use Strategy, deciding at runtime which implementation to use Several of my labs have been designed to give you a sense of the type of situation in which you would use Strategy 17

Strategy Pattern 18

Strategy Pattern Source: http://www.journaldev.com/1754/strategy-design-pattern-in-java-example-tutorial 19

Strategy Pattern When a pattern has conventional terms for the classes and interfaces, use them in your code. Other developers will understand much of how your code works as soon as they see that you are using the pattern. For example, in Strategy, use the word Strategy in the name of the interface, eg PaymentStrategy, and in the names of the implementations, eg CreditCardStrategy. 20