Sorting Algorithms

Sorting Algorithms O(n2) algorithms O(n log n) algorithms Something even better?

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

Insertion sort – O(n2) • 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()

Bubble sort – O(n2) • 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); } } }

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 Quicksort – the first O(n log n) algorithm (1962) pivot 5 2 1 9 3 8 7 2 1 3 5 9 8 7 1 2 3 5 8 7 9 1 2 3 5 7 89

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

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) Merge sort - O(n log n)(ref. last week’s lecture) 17 24 31 45 50 63 85 96 8 17 31 90 96 24 45 63 85 4 4 8 24 85 45 63 17 31 90 96 2 2 2 2 8 85 24 63 45 17 31 96 90

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 A bag of coins Total n 8 £2 2 3 4 1 5 6 7 2p 5p 10p 20p 50p 1p £1

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. The 1st phase: 314 0 802 17 1 352 314 sorted by units 802 2 By 1st digit 3 join them 17 509 4 87 87 352 5 128 199 6 509 128 119 7 8 Input list 10 buckets 9

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

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

Radix-sort - nearly finished codeOnly 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]; } }

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

divide- conquer timing sorting insertion deletion L recursion iteration binary search tree TREE STACK QUEUE LIST LIST Time complexity

Sorting Algorithms