Algorithms CSCI 235, Spring 2019 Lecture 18 Linear Sorting

Sorting without Comparisons Last lecture we showed that comparison based sorting algorithms cannot run faster than Q(nlgn). To get better efficiency, a sorting algorithm must sort based on something other than comparisons. We will examine three such sorting algorithms: Counting Sort Radix Sort Bucket Sort

Counting Sort Assumption: Counting sort assumes that each of the n input elements is an integer in the range of 1 to k, for some integer, k. Idea: For each element, x, in the input, count how many elements have a value less than x. We use this count to place x at the correct position in the sorted array. For example: If there are 3 elements less than x, we will put x at position 4 in the sorted array.

Counting Sort Algorithm COUNTING-SORT(A, B, k) // A is input array // B holds the sorted output // let C[1..k] be a new array for i = 1 to k // initialization of C C[i] = 0 for j = 1 to A.length // inspect each input element C[A[j]] = C[A[j]] + 1 // if value is i then increment C[i] // C[i] now contains the number of elements equal to i. for i = 2 to k // determine # elements <= i C[i] = C[i] + C[i-1] // C is a running sum // C[i] now contains the number of elements less than or equal to i. for j = A.length downto 1 // place each element A[j] in its B[C[A[j]]] = A[j] // correct sorted position in B C[A[j]] = C[A[j]] - 1

Example Use counting sort to sort the following array: We will work this through in class.

Analyzing Counting Sort Note: No comparisons are made during counting-sort! Also note that the values of one array are used to index another array. Running time: (we will work this out in class) First for loop: Second for loop: Third for loop: Fourth for loop: Total Running time: Is it stable? Is it in place?

Radix Sort Idea: Sort numbers according to their digits. Start with the least significant digit first. Algorithm: Radix-Sort(A, d) // d = number of digits for i = 1 to d Stable-Sort(A, i) // Sort by given digit This algorithm was developed by IBM to sort punched cards. Each card had 80 columns with a hole punched in 1 of 12 places. Sort by last column first. Repeat sorting column by column.

Radix Sort Example Sort the following list of numbers: (we will work this out in class) 443 124 232 431 132 123 321 411 Question: What if the digit sorter is not stable?

Proving Radix Sort works Proof by induction: Assume k lower order digits are sorted. Show that sorting next (k+1) digit leaves list sorted for all k+1 digits. Observation 1: If 2 digits in (k+1) position are different, then the order of the lower order digits is irrelevant. 2XY > 1XY Observation 2: If 2 digits in (k+1) position are the same, then the lower order numbers are already in the correct order. They will stay in the correct order because we are using a stable sort. XX > YY, therefore 1XX > 1YY

Running time of Radix Sort The running time of radix sort depends on which stable sorting algorithm is used to sort each column of digits. If the number of possible digits is not too large, it makes sense to use counting-sort. Each call to counting-sort takes Q(k+n) time. We have d calls to counting sort, so T(n) = Q(d(k+n)) If k = O(n) then T(n) = Q(dn). If d is constant, then T(n) = Q(n)

Bucket Sort Bucket sort is like counting-sort except it can be used when the keys are not integers. If the keys are relatively evenly distributed, we can use a general bucket sort. Idea: 1) If you have n elements in a given range, sort them into buckets that divide this range into portions of width 1/n. Do this by first creating an array of n buckets, each containing an empty list. 2) Insert each element into the list associated with the bucket whose range matches that element's value. 3) Sort each of the lists in the buckets. 4) Read elements from the lists in order back into the input array. Example: We will show an example in class.

Analyzing bucket sort Is bucket-sort stable? Is it in place? Worst case running time of Bucket sort: All numbers in the same bucket: T(n) = Q(n2) Best case running time: 1 element per bucket: T(n) = Q(n) Average case: Evenly distributed keys. On average T(n) = Q(n) (even if sorting of lists uses an algorithm that is Q(n2))