07 B: Sorting II. CS1102S: Data Structures and Algorithms. Martin Henz. March 5, Generated on Friday 5 th March, 2010, 08:31

Transcription

1 Recap: Sorting 07 B: Sorting II CS1102S: Data Structures and Algorithms Martin Henz March 5, 2010 Generated on Friday 5 th March, 2010, 08:31 CS1102S: Data Structures and Algorithms 07 B: Sorting II 1

2 Recap: Sorting 1 Recap: Sorting 2 3 CS1102S: Data Structures and Algorithms 07 B: Sorting II 2

3 Sorting Recap: Sorting Input Unsorted array of elements Behavior Rearrange elements of array such that the smallest appears first, followed by the second smallest etc, finally followed by the largest element CS1102S: Data Structures and Algorithms 07 B: Sorting II 3

4 Recap: Sorting Comparison-based Sorting The only requirement A comparison function for elements The only operation Comparisons are the only operations allowed on elements CS1102S: Data Structures and Algorithms 07 B: Sorting II 4

5 Recap: Sorting Insertion Sort: Idea Passes Algorithm proceeds in N 1 passes Invariant After pass i, the elements in positions 0 to i are sorted. Consequence of Invariant After N 1 passes, the elements in positions 0 to N 1 are sorted. That is the whole array! CS1102S: Data Structures and Algorithms 07 B: Sorting II 5

6 Recap: Sorting How to do a pass? Pass i Move element in position i to the left, until it is larger than the element to the left or until it is at the beginning of the array. CS1102S: Data Structures and Algorithms 07 B: Sorting II 6

7 Worst Case Recap: Sorting How many inversions in the worst case? A list sorted in reverse has the maximal number of inversions Maximal number of inversions N 1 i=0 i = N(N 1)/2 CS1102S: Data Structures and Algorithms 07 B: Sorting II 7

8 Average Case Recap: Sorting How many inversions in the average case? Consider the number of inversions in an list L and its reverse L r. Consider a pair of elements (x, y) Either (x, y) is an inversion in L, or in L r! Overall The sum of inversions of L and L r together is N(N 1)/2. Overall average The overall average of inversions in a given list is N(N 1)/4 CS1102S: Data Structures and Algorithms 07 B: Sorting II 8

9 Recap: Sorting Runtime of Swapping Sorting Algorithms Theorem Any algorithm that sorts its elements by swapping neighboring elements runs in Ω(N 2 ). Theorem Any algorithm that removes one inversion in each step runs in Θ(N 2 ). CS1102S: Data Structures and Algorithms 07 B: Sorting II 9

10 Shell Sort: Idea Recap: Sorting Main idea Proceed in passes h 1, h 2,...,h t, making sure that after each pass, a[i] a[i + h k ]. Invariant After pass h k, elements are still h k+1 sorted CS1102S: Data Structures and Algorithms 07 B: Sorting II 10

11 Recap: Sorting Shell Sort: Example using {1, 3, 5} CS1102S: Data Structures and Algorithms 07 B: Sorting II 11

12 Analysis Recap: Sorting Shell s Increments The worst-case running time of Shellsort, using Shell s increments 1, 2, 4,...,, is Θ(N 2 ). Hibbards s Increments The worst-case running time of Shellsort, using Hibbard s increments 1, 3, 7,...,2 k 1, is Θ(N 3/2 ). CS1102S: Data Structures and Algorithms 07 B: Sorting II 12

13 Recap: Sorting 1 Recap: Sorting 2 3 CS1102S: Data Structures and Algorithms 07 B: Sorting II 13

14 Idea Recap: Sorting Use heap to sort Build heap from unsorted array (using percolatedown) Repeatedly take minimal element (using deletemin) and place it in sorted array Drawback Will require extra array How to avoid this? Use free memory at the end of the heap! CS1102S: Data Structures and Algorithms 07 B: Sorting II 14

15 Recap: Sorting CS1102S: Data Structures and Algorithms 07 B: Sorting II 15

16 Recap: Sorting CS1102S: Data Structures and Algorithms 07 B: Sorting II 16

17 Recap: Sorting private s t a t i c i n t l e f t C h i l d ( i n t i ) { return 2 i + 1; } CS1102S: Data Structures and Algorithms 07 B: Sorting II 17

18 Recap: Sorting private s t a t i c <AnyType extends Comparable<? super AnyType>> void percdown ( AnyType [ ] a, i n t i, i n t n ) { i n t c h i l d ; AnyType tmp ; for ( tmp = a [ i ] ; l e f t C h i l d ( i ) < n ; i = c h i l d ) { c h i l d = l e f t C h i l d ( i ) ; i f ( c h i l d!= n 1 && a [ c h i l d ]. compareto ( a [ c h i l d + 1 ] ) < 0) c h i l d ++; i f ( tmp. compareto ( a [ c h i l d ] ) < 0) a [ i ] = a [ c h i l d ] ; else break ; } a [ i ] = tmp ; } CS1102S: Data Structures and Algorithms 07 B: Sorting II 18

19 Recap: Sorting public s t a t i c <AnyType extends Comparable<? super AnyType>> void heapsort ( AnyType [ ] a ) { for ( i n t i = a. l e n g t h / 2; i >= 0; i ) percdown ( a, i, a. l e n g t h ) ; for ( i n t i = a. l e n g t h 1; i > 0; i ) { swapreferences ( a, 0, i ) ; percdown ( a, 0, i ) ; } } CS1102S: Data Structures and Algorithms 07 B: Sorting II 19

20 Recap: Sorting Idea Example Implementation 1 Recap: Sorting 2 3 Idea Example Implementation CS1102S: Data Structures and Algorithms 07 B: Sorting II 20

21 Idea: Use recursion! Recap: Sorting Idea Example Implementation Split unsorted arrays into two halves Sort the two halves Merge the two sorted halves CS1102S: Data Structures and Algorithms 07 B: Sorting II 21

22 Recap: Sorting Merging Two Sorted Arrays Idea Example Implementation Use two pointers, one for each sorted array Compare values at pointer positions Copy the smaller values into sorted array Advance the pointer that pointed at smaller value CS1102S: Data Structures and Algorithms 07 B: Sorting II 22

23 Example Recap: Sorting Idea Example Implementation Sort the array CS1102S: Data Structures and Algorithms 07 B: Sorting II 23

24 Recap: Sorting Implementation of Idea Example Implementation public s t a t i c <AnyType extends Comparable<? super AnyType>> void mergesort ( AnyType [ ] a ) { AnyType [ ] tmparray = ( AnyType [ ] ) new Comparable [ a. l e n g t h ] ; mergesort ( a, tmparray, 0, a. l e n g t h 1 ) ; } CS1102S: Data Structures and Algorithms 07 B: Sorting II 24

25 Recap: Sorting Implementation of Idea Example Implementation private s t a t i c <AnyType extends Comparable<? super AnyType>> void mergesort ( AnyType [ ] a, AnyType [ ] tmparray, i n t l e f t, i n t r i g h t ) { i f ( l e f t < r i g h t ) { i n t center = ( l e f t + r i g h t ) / 2; mergesort ( a, tmparray, l e f t, center ) ; mergesort ( a, tmparray, center + 1, r i g h t ) ; merge ( a, tmparray, l e f t, center + 1, r i g h t ) ; } } CS1102S: Data Structures and Algorithms 07 B: Sorting II 25

26 Recap: Sorting Idea Example Implementation Implementation of Merge Operation private s t a t i c <AnyType extends Comparable<? super AnyType>> void merge ( AnyType [ ] a, AnyType [ ] tmparray, i n t l e f t P o s, i n t rightpos, i n t rightend ) { i n t l e f t E n d = r i g h t Pos 1; i n t tmppos = l e f t P o s ; i n t numelements = rightend l e f t P o s + 1; while ( l e f t P o s <= l e f t E n d && r i g h t Pos <= rightend ) i f ( a [ l e f t P o s ]. compareto ( a [ r i g h t Pos ] ) <= 0 ) tmparray [ tmppos++] = a [ l e f t P o s + + ] ; else tmparray [ tmppos++] = a [ r i g h t Pos + + ] ;... CS1102S: Data Structures and Algorithms 07 B: Sorting II 26

27 Recap: Sorting Idea Example Implementation Implementation of Merge Operation private s t a t i c <AnyType extends Comparable<? super AnyType>> void merge ( AnyType [ ] a, AnyType [ ] tmparray, i n t l e f t P o s, i n t rightpos, i n t rightend ) {... while ( l e f t P o s <= l e f t E n d ) tmparray [ tmppos++] = a [ l e f t P o s + + ] ; while ( r i g h t Pos <= rightend ) tmparray [ tmppos++] = a [ r i g h t Pos + + ] ; for ( i n t i = 0; i < numelements ; i ++, rightend ) a [ rightend ] = tmparray [ rightend ] ; } CS1102S: Data Structures and Algorithms 07 B: Sorting II 27

28 Next Week Recap: Sorting Idea Example Implementation Monday: Sit-in lab Wednesday lecture: Sorting III Friday: Midterm 2: Trees, Hashing, Priority Queues, Sorting I + II CS1102S: Data Structures and Algorithms 07 B: Sorting II 28