# sorting fun1 chapter 4: sorting 7 4 9 6 2 2 4 6 7 9 4 2 2 47 9 7 9 2 29 9

Post on 02-Jan-2016

220 views

Embed Size (px)

TRANSCRIPT

Chapter 4: Sorting

Sorting Fun

What Well DoQuick SortLower bound on runtimes for comparison based sortRadix and Bucket sort

Sorting Fun

Quick-Sort

Sorting Fun

Quick-SortQuick-sort is a randomized sorting algorithm based on the divide-and-conquer paradigm:Divide: pick a random element x (called pivot) and partition S into L elements less than xE elements equal xG elements greater than xRecur: sort L and GConquer: join L, E and GxxLGEx

Sorting Fun

PartitionWe partition an input sequence as follows:We remove, in turn, each element y from S and We insert y into L, E or G, depending on the result of the comparison with the pivot xEach insertion and removal is at the beginning or at the end of a sequence, and hence takes O(1) timeThus, the partition step of quick-sort takes O(n) timeAlgorithm partition(S, p)Input sequence S, position p of pivot Output subsequences L, E, G of the elements of S less than, equal to, or greater than the pivot, resp.L, E, G empty sequencesx S.remove(p) while S.isEmpty()y S.remove(S.first())if y < xL.insertLast(y)else if y = x E.insertLast(y)else { y > x }G.insertLast(y)return L, E, G

Sorting Fun

Quick-Sort TreeAn execution of quick-sort is depicted by a binary treeEach node represents a recursive call of quick-sort and storesUnsorted sequence before the execution and its pivotSorted sequence at the end of the executionThe root is the initial call The leaves are calls on subsequences of size 0 or 17 4 9 6 2 2 4 6 7 94 2 2 47 9 7 92 29 9

Sorting Fun

Execution ExamplePivot selection7 2 9 4 2 4 7 92 27 2 9 4 3 7 6 1 1 2 3 4 6 7 8 93 8 6 1 1 3 8 63 38 89 4 4 99 94 4

Sorting Fun

Execution Example (cont.)Partition, recursive call, pivot selection 2 4 3 1 2 4 7 99 4 4 99 94 47 2 9 4 3 7 6 1 1 2 3 4 6 7 8 93 8 6 1 1 3 8 63 38 82 2

Sorting Fun

Execution Example (cont.)Partition, recursive call, base case 2 4 3 1 2 4 7 1 19 4 4 99 94 47 2 9 4 3 7 6 1 1 2 3 4 6 7 8 93 8 6 1 1 3 8 63 38 8

Sorting Fun

Execution Example (cont.)Recursive call, , base case, join3 8 6 1 1 3 8 63 38 87 2 9 4 3 7 6 1 1 2 3 4 6 7 8 92 4 3 1 1 2 3 41 14 3 3 49 94 4

Sorting Fun

Execution Example (cont.)Recursive call, pivot selection7 9 7 1 1 3 8 68 87 2 9 4 3 7 6 1 1 2 3 4 6 7 8 92 4 3 1 1 2 3 41 14 3 3 49 94 49 9

Sorting Fun

Execution Example (cont.)Partition, , recursive call, base case7 9 7 1 1 3 8 68 87 2 9 4 3 7 6 1 1 2 3 4 6 7 8 92 4 3 1 1 2 3 41 14 3 3 49 94 49 9

Sorting Fun

Execution Example (cont.)Join, join7 9 7 17 7 98 87 2 9 4 3 7 6 1 1 2 3 4 6 7 7 92 4 3 1 1 2 3 41 14 3 3 49 94 49 9

Sorting Fun

Worst-case Running TimeThe worst case for quick-sort occurs when the pivot is the unique minimum or maximum elementOne of L and G has size n - 1 and the other has size 0The running time is proportional to the sumn + (n - 1) + + 2 + 1Thus, the worst-case running time of quick-sort is O(n2)number of comparisons in partition step

depthtime0n1n - 1n - 11

Sorting Fun

Expected Running TimeConsider a recursive call of quick-sort on a sequence of size sGood call: the sizes of L and G are each less than 3s/4Bad call: one of L and G has size greater than 3s/4

A call is good with probability 1/21/2 of the possible pivots cause good calls:7 9 7 1 17 2 9 4 3 7 6 1 92 4 3 1 7 2 9 4 3 7 617 2 9 4 3 7 6 1Good callBad callGood pivotsBad pivotsBad pivots

Sorting Fun

Expected Running Time, Part 2Probabilistic Fact: The expected number of coin tosses required in order to get k heads is 2kFor a node of depth i, we expecti/2 ancestors are good callsThe size of the input sequence for the current call is at most (3/4)i/2nSince each good call shrinks size to or less than previous sizeTherefore, we haveFor a node of depth 2log4/3n, the expected input size is oneThe expected height of the quick-sort tree is O(log n)The amount or work done at the nodes of the same depth is O(n)Thus, the expected running time of quick-sort is O(n log n)

Sorting Fun

Sorting Lower Bound

Sorting Fun

Comparison-Based Sorting ( 4.4)Many sorting algorithms are comparison based.They sort by making comparisons between pairs of objectsExamples: bubble-sort, selection-sort, insertion-sort, heap-sort, merge-sort, quick-sort, ...Let us therefore derive a lower bound on the running time of any algorithm that uses comparisons to sort a set S of n elements, x1, x2, , xn.Assume that thexi are distinct,which is not arestriction

Sorting Fun

Counting ComparisonsLet us just count comparisons then.First, we can map any comparison based sorting algorithm to a decision tree as follows: Let the root node of the tree correspond to the first comparison, (is xi < xj?), that occurs in the algorithm. The outcome of the comparison is either yes or no.If yes we proceed to another comparison, say xa< xb? We let this comparison correspond to the left child of the root.If no we proceed to the comparison xc < xd? We let this comparison correspond to the right child of the root. Each of those comparisons can be either yes or no

Sorting Fun

The Decision TreeEach possible permutation of the set S will cause the sorting algorithm to execute a sequence of comparison, effectively traversing a path in the tree from the root to some external node

Sorting Fun

Paths Represent PermutationsFact: Each external node v in the tree can represent the sequence of comparisons for exactly one permutation of SIf P1 and P2 different permutations, then there is at least one pair xi, xj with xi before xj in P1 and xi after xj in P2For both P1 and P2 to end up at v, this means every decision made along the way resulted in the exact same outcome. This cannot occur if the sorting algorithm behaves correctly, because in one permutation xi started before xj and in the other their order was reversed (remember, they cannot be equal)

Sorting Fun

Decision Tree HeightThe height of this decision tree is a lower bound on the running timeEvery possible input permutation must lead to a separate leaf output (by previous slide). There are n! permutations, so there are n! leaves. Since there are n!=1*2**n leaves, the height is at least log (n!)

Sorting Fun

The Lower BoundAny comparison-based sorting algorithms takes at least log (n!) timeTherefore, any such algorithm takes time at least

Since there are at least n/2 terms larger than n/2 in n!

That is, any comparison-based sorting algorithm must run in (n log n) time.

Sorting Fun

Bucket-Sort and Radix-Sort0123456789B1, c7, d7, g3, b3, a7, e

Sorting Fun

Bucket-Sort ( 4.5.1)Let be S be a sequence of n (key, element) items with keys in the range [0, N - 1]Bucket-sort uses the keys as indices into an auxiliary array B of sequences (buckets)Phase 1: Empty sequence S by moving each item (k, o) into its bucket B[k]Phase 2: For i = 0, , N - 1, move the items of bucket B[i] to the end of sequence SAnalysis:Phase 1 takes O(n) timePhase 2 takes O(n + N) timeBucket-sort takes O(n + N) time Algorithm bucketSort(S, N)Input sequence S of (key, element) items with keys in the range [0, N - 1] Output sequence S sorted by increasing keysB array of N empty sequenceswhile S.isEmpty()f S.first()(k, o) S.remove(f)B[k].insertLast((k, o))for i 0 to N - 1while B[i].isEmpty() f B[i].first()(k, o) B[i].remove(f)S.insertLast((k, o))

Sorting Fun

ExampleKey range [0, 9]Phase 1Phase 2

Sorting Fun

Properties and ExtensionsKey-type PropertyThe keys are used as indices into an array and cannot be arbitrary objectsNo external comparatorStable Sort PropertyThe relative order of any two items with the same key is preserved after the execution of the algorithm

ExtensionsInteger keys in the range [a, b]Put item (k, o) into bucket B[k - a] String keys from a set D of possible strings, where D has constant size (e.g., names of the 50 U.S. states)Sort D and compute the rank r(k) of each string k of D in the sorted sequence Put item (k, o) into bucket B[r(k)]

Sorting Fun

Lexicographic OrderA d-tuple is a sequence of d keys (k1, k2, , kd), where key ki is said to be the i-th dimension of the tupleExample:The Cartesian coordinates of a point in space are a 3-tupleThe lexicographic order of two d-tuples is recursively defined as follows(x1, x2, , xd) < (y1, y2, , yd) x1 < y1 x1 = y1 (x2, , xd) < (y2, , yd)I.e., the tuples are compared by the first dimension, then by the second dimension, etc.

Sorting Fun

Lexicographic-SortLet Ci be the comparator that compares two tuples by their i-th dimensionLet stableSort(S, C) be a stable sorting algorithm that uses comparator CLexicographic-sort sorts a sequence of d-tuples in lexicographic order by executing d times algorithm stableSort, one per dimensionLexicographic-sort runs in O(dT(n)) time, where T(n) is the running time of stableSort Algorithm lexicographicSort(S)Input sequence S of d-tuples Output sequence S sorted in lexicographic order

for i d downto 1stableSort(S, Ci)Example:(7,4,6) (5,1,5) (2,4,6) (2, 1, 4) (3, 2, 4)(2, 1, 4) (3, 2, 4) (5,1,5) (7,4,6) (2,4,6)(2, 1, 4) (5,1,5) (3, 2, 4) (7,4,6) (2,4,6)(2, 1, 4) (2,4,6) (3, 2, 4) (5,1,5) (7,4,6)

Sorting Fun

Recommended