Sort: Divide & Conquer. Data Structures and Algorithms Emory University Jinho D. Choi

Transcription

1 Sort: Divide & Conquer Data Structures and Algorithms Emory University Jinho D. Choi

2 Comparison-Based Sort Comparison complexities Selection-based Insertion-based Selection Heap Insertion Shell (Knuth) Best O(n 2 ) O(n log n) O(n) O(n) Average O(n 2 ) O(n log n) O(n 2 ) O(n 1.5 ) Worst O(n 2 ) O(n log n) O(n 2 ) O(n 1.5 ) 2

3 Divide and Conquer Given a problem - Divide the problem into sub-problems (recursively). - Conquer sub-problems, which effectively solves the super problem. Sorting algorithms Merge Quick Best O(n log n) O(n log n) Average O(n log n) O(n log n) Worst O(n log n) O(n 2 ) Why ever use QuickSort then? 3

4 Divide and Conquer Merge - Divide a list into two sub-lists. - Merge sub-lists into a super list in which all keys are sorted. Quick - Pick a pivot key in a list. - Exchange keys between left and right partitions such that all keys in the left and right partitions are smaller or bigger than the pivot key, respectively. - Repeat this procedure in each partition, recursively. 4

5 Merge Sort

6 Merge Sort private T[] temp; // n-extra public void sort(t[] array, int beginindex, int endindex) { if (beginindex + 1 >= endindex) return; int middleindex = beginindex + (endindex - beginindex) / 2; sort (array, beginindex, middleindex); // divide sort (array, middleindex, endindex); merge(array, beginindex, middleindex, endindex); // conquer 6

7 Merge Sort protected void merge(t[] array, int beginindex, int middleindex, int endindex) { int fst = beginindex, snd = middleindex; copy(array, beginindex, endindex); for (int k=beginindex; k<endindex; k++) { if (fst >= middleindex) assign(array, k, temp[snd++]); else if (snd >= endindex) assign(array, k, temp[fst++]); else if (compareto(temp, fst, snd) < 0) assign(array, k, temp[fst++]); else assign(array, k, temp[snd++]); // no key left in the 1st half // no key left in the 2nd half // 1st key < 2nd key 7

8 Extra Spaces in Merge Sort

9 Quick Sort Pick a pivot and swap between left and right partitions

10 Quick Sort public void sort(t[] array, int beginindex, int endindex) { if (beginindex >= endindex) return; // conquer int pivotindex = partition(array, beginindex, endindex); sort(array, beginindex, pivotindex); sort(array, pivotindex+1, endindex); // divide 10

11 Quick Sort protected int partition(t[] array, int beginindex, int endindex) { int fst = beginindex, snd = endindex; while (true) // find fst > pivot { while (++fst < endindex && compareto(array, beginindex, fst) >= 0); while (--snd > beginindex && compareto(array, beginindex, snd) <= 0); if (fst >= snd) break; // find snd < pivot swap(array, fst, snd); // exchange swap(array, beginindex, snd); return snd; // set pivot 11

12 Intro Sort The worse-case complexity of Quicksort is O(n 2 ). Quicksort is the fastest on average. Several other sorting algorithms give faster worst-case complexities than Quicksort. Quicksort for random cases. Another algorithm for the worst case. How to determine if Quicksort is meeting the worst-case? 12

13 Intro Sort public IntroSort(AbstractSort<T> engine, Comparator<T> comparator) { super(comparator); this.engine = engine; guaranteed to be O(n log public void sort(t[] array, int beginindex, int endindex) { final int maxdepth = getmaxdepth(beginindex, endindex); sortaux(array, beginindex, endindex, maxdepth); protected int getmaxdepth(int beginindex, int endindex) { return 2 * (int)log2(endindex - beginindex); private double log2(int i) { return Math.log(i) / Math.log(2); maximum depth of the partitions 13

14 Intro Sort public void sortaux(t[] array, int beginindex, int endindex, int maxdepth) { if (beginindex >= endindex) return; if (maxdepth == 0) engine.sort(array, beginindex, endindex); else { int pivotindex = partition(array, beginindex, endindex); sortaux(array, beginindex, pivotindex, maxdepth-1); sortaux(array, pivotindex+1, endindex, maxdepth-1); meeting the worst case 14

15 Comparison - Comparison (Random) Heap Shell Merge Quick Intro-H Intro-S Σ of comparisons quick intro-h intro-s List sizes 15

16 Comparison - Assignment (Random) Heap Shell Merge Quick Intro-H Intro-S Σ of assignments quick intro-h intro-s List sizes 16

17 Comparison - Speed (Random) 800 Heap Shell Merge Quick Intro-H Intro-S Σ of 1K iterations (ms) List sizes 17

18 Comparison - Speed (Ascending) 4000 Heap Shell Merge Quick Intro-H Intro-S Σ of 1K iterations (ms) List sizes 18

19 Comparison - Speed (Descending) 3000 Heap Shell Merge Quick Intro-H Intro-S Σ of 1K iterations (ms) List sizes 19

20 Agenda Exercise - Reading