Sorting Algorithms. For special input, O(n) sorting is possible. Between O(n 2 ) and O(nlogn) E.g., input integer between O(n) and O(n)

Transcription

1 Sorting

2 Sorting Algorithms Between O(n ) and O(nlogn) For special input, O(n) sorting is possible E.g., input integer between O(n) and O(n)

3 Selection Sort For each loop Find max Swap max and rightmost element Exclude rightmost element Loop until one element left

4 Finding the Recursive Structure The largest item Running time: (n-)+(n-)+ ++ = O(n ) Worst case Average case

5 selectionsort(a[], n) Sort array A[... n] { } for last n downto { } Find max A[k] among A[... last]; A[k] A[last]; Swap A[k] and A[last] Running time: for loop in : n- times # of comparisons to find max in : n-, n-,,, swap in : constant time (n-)+(n-)+ ++ = O(n )

6 Input Array Find max () Swap and the rightmost number () Find max except the rightmost number. () Swap with the rightmost number () Find max except the two rightmost numbers ()... Swap with the rightmost number () Final Array Selection Sort Example First loop Second loop

7 Bubble Sort Running time: (n-)+(n-)+ ++ = O(n ) Worst case Average case

8 bubblesort(a[], n) Sort A[... n] { } for last n downto Swap-- for i to last if (A[i] > A[i+]) then A[i] A[i+]; Running time: : for loop n- times : for loop n-, n-,,, times : constant time (n-)+(n-)+ ++ = O(n )

9 Input array Input array Compare adjacent pairs from the left Compare adjacent pairs from the left Swap if the order is not right Swap if the order is not right Bubble Sort Bubble Sort Bubble Sort Bubble Sort Example Example Example Example Exclude the rightmost number () Exclude the rightmost number ()

10 Swap if the pair is not orderly Swap if the pair is not orderly Starting from the left, compare adjacent pairs Starting from the left, compare adjacent pairs Exclure Exclure the rightmost value () the rightmost value ()

11 Keep excluding the values by repeating the loop Keep excluding the values by repeating the loop Process the final two elements Process the final two elements

12 Insertion Sort Running time: O(n ) Worst case: ++ +(n-)+(n-) Average case: ½ (++ +(n-)+(n-))

13 insertionsort(a[], n) Sort A[... n] { } for i to n Insert A[i] into the right position in A[... i]; ---- Running time: : for loop n- times : i- times comparison in the worst case Worst case: ++ +(n-)+(n-) = O(n ) Average case: ½ (++ +(n-)+(n-)) = O(n )

14 Inductive Verification of Insertion Sort A[] Sorted If A[ k] sorted By the insertion in, A[ k+] are sorted

15 mergesort(a[ ], p, r) Sort A[p... r] { } if (p < r) then } Mergesort then { q (p+q)/; Midpoint of p, q mergesort(a, p, q); Sort the left mergesort(a, q+, r); Sort the right merge(a, p, q, r); Merge merge(a[ ], p, q, r) { Two sorted array A[p... q] and A[q+... r] Merge them into one array A[p... r] }

16 Input array given Mergesort Example Partition the array Sort them independently Merge

17 p q r i j t i j t i j t Merge Example

18 i j t i j t i j t

19 i j t i j t i j t

20 i j t

21 Animation (Mergesort) Running time: O(nlog logn)

22 Quicksort quicksort(a[], p, r) Sort A[p... r] { if (p < r) then { q = partition(a, p, r); Partition quicksort(a, p, q-); Sort the left quicksort(a, q+, r); Sort the right } } partition(a[], p, r) { Arrange the elements in A[p... r] according to A[r] Return the position of A[r]; }

23 Animation (Quicksort) Average running time: O(nlog logn) Worst running time: O(n )

24 Quicksort Example In the input array, set the first value as a pivot Partition the input array so that smaller elements on the left, and bigger elements on the right (a) Sort the left and the right independently (b)

25 p r i j i j i j i j i j i j Partition Example (a) (b) (c)

26 i j i j i j i i (d) (e)

27 Heapsort Heap Complete binary tree that satisfies the following Each node s value is not bigger than its children Heapsort Convert the input array to a Heap, and remove top element from the Heap one by one

28 heapsort(a[ ], n) { } buildheap(a, n); Make Heap for i n downto { } A[] A[i]; Swap heapify(a,, i-); O(nlog logn) time in the worst case

29 Heap Heap Not a Heap

30 Not a Heap

31 Heap can be represented in an array A

32 Heapsort Example Remove (a) (b) (c) Remove (f) (e) (d)

33 Remove (g) (h) (k) Remove (i) Remove (j)

34 O(n) Sort Lower bound of sorting algorithms is Ω (n logn) If the elements satisfy a certain condition, O(n) Counting Sort Elements magnitude is between O(n) ~ O(n) Radix Sort Elements has the number of digits less than k (k is constant)

35 Counting Sort countingsort(a[ ], n) simple version { A[ ]: Input Array, n: Input Size } for i = to k C[i] ; for j = to n C[A[j]]++; C[i] here : total number of elements with i value for i = to k print C[i] i s; print i for C[i] times

36 Radix Sort radixsort(a[ ], d) { } for j = d downto { } Stable sort Do a stable sort on A[ ] by th j digit; The order of items with a same value does not change after the sorting

37 Running time: O(n) d: : a constant

38 Efficiency Worst Case Average Case Selection Sort n n Bubble Sort n n Insertion Sort n n Mergesort nlogn nlogn Quicksort n nlogn Counting Sort n n Radix Sort n n Heapsort nlogn nlogn