文章目录
Sort in linear time
-
How fast can we sort ?
It depends on model of what you can do with the elements. -
Familiar sort algorithm
1)quicksort(Θ(nlgn))(unstable)
2)heapsort(Θ(nlgn))(unstable)
3)merge sortr(Θ(nlgn))(stable)
4)Insertion sort(Θ(n^2)) (stable)
Question: Can we do better than Θ(nlgn)?
Comparison sort(model)
In this model, we only use comparison to determine relative order of elements.
- e.x. sort A(a1,a2,a3)
We can draw an tree like follows:
The oval denotes a comparison, go to the left child node if a<b for a:b.The rectangle denetes the final result.
In general ,<a1,a2,a3,…,an> has following futures:
- Each internal node, so every non-leaf node has a label i:j(i,j={1,2,…,n}).
- Compare ai versus aj.
- Left subtree gives subsequent conparison if ai<=aj.
- Right subtree gives subsequent comparison if ai>aj.
- Each leaf node gives a comparison <Π(1),Π(2),…Π(n)>,such that aΠ(1)<= aΠ(2) <= aΠ(3) <= …<=aΠ(n).
- Decision tree & Conparison sorts
- One tree for each n.
- View algorithms as folks spliting whenever if makes a comparison.
- Tree exists comparison along aw possible institution traces.
- Running time (#comparison/nums of comparison) = length of path
Worst-case time = height of the tree
- Lower bound in decision-tree sort
Any decision tree sorting n elements has height Ω(nlgn).
Proof: - #leaves must be >= n
- for a binary tree ,height h->#leaves<=2^h -> n!<=2^h -> h>=nlgn!
- Stirling formula: h>=nlgn!>= lg(n/e)^n = nlog(n/e) = nlgn - n = Ω(nlgn)
□
What’s more, merge sort and heapsort are asymptotic optimal.Randomized quicksort is too,in exception.
Counting sort - sort in linear time
- Counting sort
Input: A[1...n] each A[i] = {1,2,3,4,..,k},which means we konw that A[i] has an upper bound.
Output:B[1...n]= Sorting of A
We need auxiliary storage:C[1,2,...k]
- Futures:
- apply for samll-range numners
- a stable algorithm
Pseudocode:
for i ← 1 to k //Initial C
do C[i] ← 0
for j ← 1 to n 。// Count the number
do C[A[j]] ← C[A[j]]+1
for i ← 2 to k
do C[i] ← C[i]+C[i-1]
for j ← n downto 1 // for stability
do B[C[A[j]]] ← A[j]
C[A[j]] ← C[A[j]]-1
Ex:
A=4 1 3 4 3 C=0 0 0 0
C=1 0 2 2
C‘=1 1 3 5
B=0 0 3 0 0 C‘=1 1 2 5
B=0 0 3 0 4 C‘=1 1 2 4
B=0 3 3 0 4 C‘=1 1 1 4
B=1 3 3 0 4 C‘=0 1 1 4
B=1 3 3 4 4 C‘=0 1 1 3
T(n) = θ(k+n), apply for some arrays with small k.
Radix Sort(基数排序)
- futures
- apply for large-range sort
- stable
- e.x.
329 720 720 329
457 355 329 355
657 436 436 436
839 457 839 457
436 657 355 657
720 329 457 720
355 839 657 839 - Proof of correctness - induct on digit position t
- Assume by induction sorted on low-order t-1 digits.
- Sort on digit t
-> if two elems have same Tth digit.
stability ->same order -> sorted order
-> if two elems have different Tth digit.
sortedd order
- Analysis
- Use counting sort for each turn
- suppose n integers, each n bits.(range 0~2^b-1)
- Split into b/r “digit”, each r bits long.
Running time:O(b/r·(n+k))=O(b/r·(n+2^r))
Take the derivative to get the miniunm, we kenow that T(n) = O(bn/lgn) when r is lgn bits long .