Syllabus. 3. Sorting. specification

Transcription

1 Introduction to Algorithms Syllabus Specification Bubble Sort Selection Sort Insertion Sort Merge Sort Quicksort Linear-Time Median Sorting in Linear Time Specification Primitives: semantics and cost Design Analysis Optimality of Comparison-Based Sorting specification Specification: Fix set X with total order. Input: N and finite sequence x in array x[1 N] 1, x N X and array π[1 N] := identity permutation of {1, N} Output: Permuted Permutation array π of x π {1,...N} such such that that x π(1) x π(1) x π(n) x π(n) Primitives: ordered comparison x[n] x[m]? cost 1 swapping swapping π[n] π[m] cost 1 cost 1 cost 1 Preprocessing data in order to accelerate queries.

2 Bubble Sort Procedure BubbleSort ( x[n] ] ) For m := N downto 2 do For k := 1 to m 1 1 do If x[k] ] > x[k+1] then Endif Swap (x[k]], x[k+1]) Primitives: Comparison x[n] x[m]? Swapping runtime O(N²) Correctness: x[1], x[m] x[m+1] x[n] Procedure SelectSort ( x[n] ] ) For m := 1 to N 1 1 do min := m; For k := min+1 to N do If x[k] ] < x[min] then min := k ; Endif Select Sort Primitives: Comparison x[n] x[m]? Swapping Swap( x[m], x[min] ] ) runtime O(N²) Correctness: x[1] x[m-1] x[m], x[n]

3 Procedure InsertSort ( x[n] ] ) For m := 2 to N do y := x[m]; k := m 1; While k>0 and x[k]> ]>y x[k+1] := x[k] k := k 1 Endwhile x[k+1] := y Insert Sort Primitives: Comparison x[n] x[m]? Swapping runtime O(N²) Correctness: x[1] x[m-1] x[m], x[n] Procedure MergeSort ( x[n] ] ) If N 1 return. l := N/2 ; r := N/2 ; array y[l] ], z[r] ] ; For m := 1 to l do y[m]:= x[m]; For m := 1 to r do z[m]:= x[l+m]; MergeSort(y); MergeSort(z); While l>0 and r>0 do ; If then else x[l+r] ] := y[l] ] ; l:= :=l 1 z[r] y[l] x[l+r] ] := z[r] ] ; r:= :=r 1 While l>0 do ; x[l+r] ] := y[l] ] ; l:= :=l 11 ; Endwhile While r>0 do ; x[l+r] ] := z[r] ] ; r:= :=r 11 ; Endwhile Merge Sort runtime T(N) = 2 T(N/2) 2 +O(N) + O(N log N) memory O(N log N)

4 Procedure QuickSort ( x[] ; l,r ) If Function l r return. return Partition. // x[l] x[r] ( x[] ; l, r sorted ; y) // partitions x[l....r] into x[l....m] entries <y // and x[m r] those y.. Returns m. y := x[ (l+r x[l]; x[r]; l+r)/2 )/2 ]; X // // pivot a := l ; b := r ; While a < b do While a<b and x[a] < y do a := a+1 Endwhile; While a<b and x[b] y do b := b-1 Endwhile; Swap(x[a], ],x[b]);]); Endwhile ; Return // l a; a = b r QuickSort ( x, l, a-1); QuickSort ( x, b, r ); c N log( log(n) ) =: T(N) = c N ε log( Ansatz = c N log( log(n) + l Quick Sort T(N) = T(N ε? ) + T(N (1?)) ε ) +O(N) + O(N log N) a=b for every fixed ε (0,1) ε (r-l+1) a l (1-ε) (r-l+1) ε (r-l+1) r a (1-ε) (r-l+1) log(n ε) ) + c N (1-ε) log( log(n (1-ε)) ) + N ) + N c (ε log( log(ε) ) + (1-ε) log(1 log(1-ε)) + N r Function Partition ( x[] ; l, r ; y) // partitions x[l....r] into x[l....m] entries <y // and x[m r] those y.. Returns m. Median Revisited W.l.o.g. x[n] x[m] for all n m K-th order statist.: m s.t. #{n : l n r, x n < x m } = K Lemma: ε (r-l+1) Median a l of (1-ε) (r-l+1) 5-medians is ε (r-l+1) at least r a ½ ⅗ = (1-ε) (r-l+1) 30% of entries, and < at most 70%. Output: m such that 0.3 N #{n : x n x m } 0.7 N+1

5 Function Partition ( x[] ; l, r ; y) // partitions x[l....r] into x[l....m] entries <y // and x[m r] those y.. Returns m. Function ApproxMed ( x[] ; l, r) Process x[l......r]] in groups of 5, sorting each one to find its median. Then call OrderStat to determine the median of these 5medians. n := r l+1 K-th order statist.: m s.t. #{n : l n r, x n < x m } = K T A (n) = O(n) + T O (0.2 n), Linear-time Median W.l.o.g. x[n] x[m] for all n m Function OrderStat ( x[] ; l, r, K) K While l<r do Call ApproxMed in order to determine an approximate median of x[l r]. Partition x[l r] accordingly. Proceed to the left (=decrease r) /right (=increase l) ) accordingly. Lemma: Median of 5-medians is at least ½ ⅗ = 30% of entries, and < at most 70%. T O (n) = T A (n) + O(n) + T O (0.7 n) Optimality Specification: Fix set X with total order. with values in X Output: Permutationπ Definition: A Decision Tree for sorting N elements is a binary tree whose nodes are labeled x[i] x[j]?, 1 i<j N. and whose leaves are labeled with permutations π such that every input x=x[1 N] ends up in a leaf whose label π satisfies x[π[1]] x[π[n]]. Primitives 2,3,1

6 Optimality Lemma: a) For fixed N, every sorting algorithm of worst-case runtime T(N) can be unrolled into a decision tree for sorting N elements of depth T(N). b) Every permutation x=π ends up in the unique leaf with label π - 1. c) A binary tree with N! leaves has depth log(n!)=θ(n log N) Definition: A Decision Tree for sorting N elements is a binary tree whose internal nodes are labeled x[i] x[j]?, 1 i<j N. and whose leaves are labeled with permutations π such that every input x=x[1 N] ends up in a leaf whose label π satisfies x[π[1]] x[π[n]]. 2,3,1 Counting Sort Specification: Fix set X={1, ={1, M}! with key values in X Output: Permuted array y=x π s.t. x.key[π[1]] x.key[π[n]] integer array count[1 [1 M]; For m:=1 to M do count[m] ] := 0; For n:=1 to N do count[x.key x.key[n]]++ ++; sum := 1; For m:=1 to M do temp := count[m]; count[m]:= sum; M sum += temp; ; runtime For n:=1 to N do O(N+M) y[count[x[n]. ].key]++ ++] := x[n]; N N 2 1

7 Radix Sort Specification: Fix set X={ ={0,1} m with lexicographical order. with values in X Output: Permuted array y=x π s.t. x[π[1]] x[π[n]] Quick-/Mergesort in Bit-model: O(N log N m) RadixSort( x[], l, r, m ); // Sort x[l r] w.r.t. bits #m #1 If l=r or m<1 then return; // Put all entries with 0 as bit #m before those with 1: mid := Partition ( x[], l, r, m); RadixSort( x[], l, mid, m-1); RadixSort( x[], mid+1, r, m-1); 0 b m-1 b 2 b 1 < 1 c m-1 c 2 c 1 O(N m) operations Bit-model: O(N m²)