1. Sorting Algorithms O(n 2 ) algorithms O(n log n) algorithms Something even better?

2. Sorting a frequently used process Nature tends towards disorder Human prefer order e.g. address books shopping lists databases

3. Insertion sort – O(n 2 ) Commonly used for hand-sorting Use two lists – unsorted and sorted unsorted = input list (size = n) sorted = an empty list loop from i =0 to n-1 do n loops sorted.insertInOrder(unsorted[i]) o(n) You have just implemented insertInOrder()

4. Bubble sort – O(n 2 ) Imagine an unsorted list held vertically Smaller values are “light” and bubble up void bubbleSort() { int i,j; int last=current_size-1; for(i=0;i<last; i++) { fot(j=last;j>I;j--) { if(data[j] is less than data[j-1]) swap(j, j-1); }

5. Quicksort – the first O(n log n) algorithm (1962) Using divide-and- conquer technique Select a pivot, split list into 2 sublists: smaller and larger Repeat this to all sublists until sublist’s size is reduced to 1 5 2 1 9 3 8 7 2 1 3 5 9 8 7 1 2 3 5 7 8 9 1 2 3 5 8 7 9 pivot

6. Quicksort – average O(n log n) the worst case O(n 2 ) quicksort(int fm, int to) { int p; // pivot position if(fm < to) { p = partition(fm,to); quicksort(fm, p-1); quicksort(p+1,to); } 5 2 1 9 3 8 7 2 1 3 5 9 8 7 1 2 3 5 7 8 9 1 2 3 5 8 7 9 Time per level O(n) O(n log n)Total =

7. Merge sort - O(n log n) (ref. last week’s lecture)  Why O(n log n)?  Merging 2 sorted lists takes O(n1+n2), n1 and n2 are sizes of these 2 lists  There are log n levels of merging, each level takes O(n) 17 24 31 45 50 63 85 96 85 24 63 45 17 31 96 90 24 8545 6317 3190 96 24 45 63 85 17 31 90 96 8 8 844 2222

8. Can we have an O(n) sorting algorithm? Bucket-sort Yes, if we know the range of sorted items. Let the range be [1,k], If(k<O(n)), we can use extra momey to make k “buckets”. Then put each item into the correct bucket. We can do sorting without comparisons! Why O(n)? – only need go through n items once 1p 2p5p10p20p50p 1 234 56 A bag of coins £1 £2 Total n 7 8

9. Radix-sort - repeatedly apply Bucket-sort digit-by-digit An example – assume that we know sorted items are integers at most 3 digits (i.e. less than 1000) Input list – 314,17,802,509,87,352,199,128. Input list10 buckets 314 802 17 509 87 352 199 128 By 1 st digit 0 1 2 3 4 5 6 7 8 9 join them 802 352 314 17 87 128 509 119 The 1 st phase: sorted by units

10. Radix-sort – cont. The 2 nd phase, sorted by 2 nd digit (tens). list from last phase – 802,352,314,17,87,128,509,119. list from last phase 10 buckets By 2 nd digit 0 1 2 3 4 5 6 7 8 9 802 352 17 87 128 509 119 314 802 352 17 87 128 509 119 314 join them

11. Radix-sort – cont. The last phase, sorted by 3 rd digit. list from last phase – 802,509,314,17,119,128,352,87. list from last phase sorted! By 3 rd digit 0 1 2 3 4 5 6 7 8 9 802 352 17 87 128 509 119 314 802 352 17 87 128 509 119 314 join them

12. Radix-sort - nearly finished code Only for students having problem with Java programming! void radixSort() { int k,j; int b0,b1,b2,b3,b4,b5,b6,b7,b8,b9; // need 10 counters for 10 buckets // declare 10 buckets, B0, B2, ……, B9 String[] B0 = new String[limit]; …… // add other 9 more declarations for(k=1; k<5; k++) { // loop for digits. (we know that there are not more than 5 digits) b0=b1=b2=b3=b4=b5=b6=b7=b8=b9=0; // set all counter to 0 for(j=0; j<current_size; j++) { // loop for all items in the list, put them into correct buckets char c = Func.getNthDigit(data[j], k); switch (c) { case '0': B0[b0++]=data[j]; break;...... case '9': B9[b9++]=data[j]; break; } // join the buckets j = 0; for(k=0; k<b0; k++) data[j++] = B0[k];.... for(k=0; k<b9; k++) data[j++] = B9[k]; }

13. Radix-sort time complexity? O(n×k) where n is the length of the given list, k is the maximum number of digits used in the list To satisfy O(n×k) =< O(n log(n)), we need k =< log(n) Bucket-sort or Radix-sort – trade off between space and time

14. Time complexity LISTLIST STACKSTACK QUEUEQUEUE TREETREE binary search tree sorting divide- conquer timing L LISTLIST insertion deletion