Scribd
Upload
78 views21 pages

Sorting: - Dan Barrish-Flood

The document discusses various sorting algorithms, including quicksort, counting sort, and radix sort. It explains that quicksort has a worst-case running time of Θ(n2) but an average-case running time of Θ(nlogn). Counting sort and radix sort can sort in linear Θ(n) time by using additional information about the keys beyond just comparisons, like using keys as array indices or examining digits/bits of keys. Radix sort works by sorting on each digit or field separately from least to most significant.

Uploaded by

Balraj Singh Grewal
Copyright
© Attribution Non-Commercial (BY-NC)
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
78 views21 pages

Sorting: - Dan Barrish-Flood

The document discusses various sorting algorithms, including quicksort, counting sort, and radix sort. It explains that quicksort has a worst-case running time of Θ(n2) but an average-case running time of Θ(nlogn). Counting sort and radix sort can sort in linear Θ(n) time by using additional information about the keys beyond just comparisons, like using keys as array indices or examining digits/bits of keys. Radix sort works by sorting on each digit or field separately from least to most significant.

Uploaded by

Balraj Singh Grewal
Copyright
© Attribution Non-Commercial (BY-NC)
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
You are on page 1/ 21

SORTING

Dan Barrish-Flood

heapsort
made file 3-Sorting-Intro-Heapsort.ppt

Quicksort
Worst-case running time is (n2) on an input array of n numbers. Expected running time is (nlgn). Constants hidden by are quite small. Sorts in place. Probably best sorting algorithm for large input arrays. Maybe.
3

How does Quicksort work? based on divide and conquer paradigm (so is merge sort). Divide: Partition (re-arrange) the array A[p..r] into two (possibly empty) sub-arrays A[p .. q-1] and A[q+1 .. r] such that each element of A[p .. q-1] is each element of A[q], which is, in turn, each element of A[q+1 .. r]. Compute the index q as part of this partitioning procedure. Conquer: Sort the two sub-arrays A[p .. q-1] and A[q+1 .. r] by recursive calls to quicksort. Combine: No combining needed; the entire array A[p .. r] is now sorted!
4

Quicksort

Partition in action

Quicksort Running Time, worse-case


worst-case occurs when partition yields one subproblem of size n-1 and one of size 0. Assume this bad split occurs at each recursive call. partition costs (n). Recursive call to QS on array of size 0 just returns, so T(0) = 1, so we get: T(n) = T(n-1) + T(0) + (n), same as... T(n) = T(n-1) + n just an arithmetic series! So... T(n) = (n2) (worst-case) Under what circumstances do you suppose we get this worst-case behavior?
7

Quicksort, best-case
In the most even possible split, PARTITION yields two subproblems each of size no more than n/2, since one is of size floor(n/2), and one is [ceiling(n/2)]-1. We get this recurrence, with some OK sloppiness: T(n) = 2T(n/2) + n (look familiar?) T(n) = O(nlgn) This is asymptotically superior to worstcase, but this ideal scenario is not likely...
8

Quicksort, Average-case

suppose the great and awful splits alternate levels in the tree. the running time for QS, when levels alternate between great and awful splits, is just the same as when all levels yield great splits! (with a slightly larger constant hidden by the big-oh notation). So, average case... T(n) = O(nlgn)
9

A lower bound for sorting (Sorting, part 2)

We will show that any sorting algorithm based only on comparison of the input values must run in (nlgn) time.
10

Decision Trees Tree of comparisons made by a sorting algorithm. Each comparison reduces the number of possible orderings. Eventually, only one must remain. A decision tree is a full (not complete) binary tree; each node is a leaf or has degree 2.

11

Q. How many leaves does a decision tree have? A. There is one leaf for each permutation of n elements. There are n! permuatations. Q. What is the height of the tree? A. # of leaves = n! 2h Note the height is the worst-case number of comparisons that might be needed.
12

Show we cant beat nlgn


recall n! 2h ... now take logs lg(n!) lg(2h) lg(n!) h lg2 lg(n!) h ... just flip it over h lg(n!) ( lg(n!) = (nlgn) ) ...Stirling, CLRS p. 55 h = (nlgn) QED In the worst case, (nlgn) comparisons are needed to sort n items.
13

Sorting in Linear Time !!!


The (nlgn) bound does not apply if we use info other than comparisons. Like what other info?

1. Use the item as an array index. 2. Examine the digits (or bits) of the item.

14

Counting Sort
Good for sorting integers in a narrow range Assume the input numbers (keys) are in the range 0..k Use an auxilliary array C[0..k] to hold the number of items less than i for 0 i k if k = O(n), then the running time is (n). Counting sort is stable; it keeps records in their original order.
15

16

Counting Sort in action

17

Radix Sort
How IBM made its money, using punch card readers for census tabulation in early 1900s. Card sorters worked on one column at a time. Sort each digit (or field) separately. Start with the least-significant digit. Must use a stable sort.
RADIX-SORT(A, d) 1 for i 1 to d 2 do use a stable sort to sort array A on digit i
18

Radix Sort in Action

19

Correctness of Radix Sort


induction on number of passes base case: low-order digit is sorted correctly inductive hypothesis: show that a stable sort on digit i leaves digits 1...i sorted
if 2 digits in position i are different, ordering by position i is correct, and positions 1 .. i-1 are irrelevant if 2 digits in position i are equal, numbers are already in the right order (by inductive hypotheis). The stable sort on digit i leaves them in the right order.

Radix sort must invoke a stable sort.


20

Running Time of Radix Sort


use counting sort as the invoked stable sort, if the range of digits is not large if digit range is 1..k, then each pass takes (n+k) time there are d passes, for a total of (d(n+k)) if k = O(n), time is (dn) when d is const, we have (n), linear!
21

You might also like