ANNOUNCEMENTS

Reading - Chapter 8
Reminder - HW3 due in class Tuesday 04/06/99
 
 

REVIEW

Quicksort

• Algorithm
• Pivot choice
• Partitioning in place
• Implementation
• Analysis - Best, worst, avergage and recurrence formulas

TODAY
 

• The selection problem
• General lower bounds of sorting
• Basket sort
• Generalized radix sort
• External sorting
• Equivalence problem

QUICKSELECT

Use quicksort to solve selection problem
Recall:  Find kth element out of N elements, let |Si| = Number of elements in S

Pivot p is an element of S
Partition S-{P} into S1, S2 just like quicksort
If k <= |Si|, kth sublet G S1
    return quickselect (S1, k)
If k = 1 + |Si|, kth sublet = p
Else kth sublet in S2
    return quickselect (S2, k-|S1|-1)

We use one recursive call instead of 2
Worst case O(N^2)
Average case O(N)

Best-case

T(N)    = T(N/2) + cN
            = T(N/2) + C(N/2) + cN
            = T(N/8) + C(N/4) + C(N/2) + CN
            ...
            = T(1) + C(2+4+....+N/2+N)
            = T(1) + CN + (2/N + 4/N +...+N/2+1)
            = T(1) + CN * (1+1/2+1/4+...2/N)
            = O(N)
 
 

GENERAL LOWER BOUND FOR SORTING

We have O(NlogN) algorthims for sorting
Can we do better?

We will show that any algorithm for sorting using only comparisons requires Omega(NlogN) comparisons in the worst case
and on average as well.

• Mergesort, heapsort optimal in worst case (to within a constant factor)
• Quicksort optimal on average (to within a constant factor)

• Binary tree
• Nodes - Possible orderings of nodes, consistent with comparison node
• Results of comparisons are the edges
• Every algorithms sorting by comparisons can be written as a decision tree

Binary decision tree of depth d - At worst 2^d leaves
    N elements => N! permutations
    Need 2^d = N!
    d  = logN!
        = logN + log(N-1) + log(N-2) +...+log1
        >= logN + log(N-1) + log(N-2) +...+log(N/2)
        >= (N/2)log(N/2)
        >= N/2log(N) - N/2(log2)
        == Omega(NlogN)
 
        Number of decisinos in worst case = depth of decision tree
        ==> lower bound = Omega(NlogN)
 

BUCKET SORT

Sort a set of positive integers A1, ..., AN suck that each Ai < M

• Create an array called count[] of size M
• Each time read a number i increment count[i]
• O(N) read
• O(M) output
• O(N+M) total

EXTERNAL SORTING
 

• Input > memory, how to sort input
• Elements on tape - can be accessed sequentially
• Want to minimize accesses (i.e. read as few blocks as possible)
• How?

• Problem because accesses nonsequential
• Shell a[i], a[i-h_k]
• Quicksort a[left], a[center], a[right]

• One tape device - Omege(N^2) disk accesses
• Why?  Any algorithm that sorts by accessing adjacent elements requires Omega(N^2) on the average
• need at elast 2 tape drives to do efficient sorting
• Assume at least 3 tape drives for simplicity

• Read block of input
• Sort block in memory
• Write to one of the tapes
• Merge sorted tapes
• Simple algorithm - assume can hod/sort M records at a time

Takes log(N/M) passes + initial runstruct pass ==> i.e. log(Number of blocks of data)
We used a mutil-way merge - k-way merge instaed of a just 2-way
Takes log_k(N/M)
Merge - consider k elements, use priority queue, deletemin
Problem - k-way merge requires 2k tapes  ==> expensive
 

POLYPHASE MERGE

k-way merge with only k+1 tapes.  Don't split evenly, split unevenly.

What is good about an uneven distribution?
Number runs = FibN
==> 2 sets of runs Fib(N-1), Fib(N-2)
Generalized for k : Fib^(k)N = Fib^(k)(N-1) + Fib^(k)(N-2) + ... + Fib^(k)(N-k)
 

REPLACEMENT SELECTION

• So far read M at a tiem, sort, output
• But once 1st record outputed can readanother element
• If new element > outputed element, can consider as part of run

• Use priority queue
• Deletemin
• Add to vacat space if < element
• Add to priority queue if > element