CS Lecture 5. Vidroha debroy. Material adapted courtesy of Prof. Xiangnan Kong and Prof. Carolina Ruiz at Worcester Polytechnic Institute

Transcription

1 CS 3353 Lecture 5 Vidroha debroy Material adapted courtesy of Prof. Xiangnan Kong and Prof. Carolina Ruiz at Worcester Polytechnic Institute Searching for a number Find a specific number

2 Searching for a number Find a specific number 91 - what about now? Why Sorting? Practical Application People by last name Countries by population Search engine results by relevance Fundamental to other algorithms Different algorithms have different asymtotic and constantfactor trade-offs no single best sort for all scenarios knowing one way to sort just isn't enough Keeping data in order allows it to be searched more efficiently 2

3 Sorting Sorting: Rearranging the values in an array or collection into a specific order (usually into their "natural ordering"). one of the fundamental problems in computer science it is estimated that 25~50% of all computing power is used for sorting activities. Popular Sorting algorithms: bubble sort: swap adjacent pairs that are out of order selection sort: look for the smallest element, move to front insertion sort: build an increasingly large sorted front portion merge sort: recursively divide the array in half and sort it heap sort: place the values into a sorted tree structure quick sort: recursively partition array based on a middle value Sorting Example Bubble Sort 3

4 Problem Definition Sorting takes an unordered collection and makes it an ordered one Input: Output: One Idea: Bubble Water Air

5 "Bubbling Up" the Largest Element Traverse a collection of elements Move from the front to the end Bubble the largest value to the end using pairwise comparisons and swapping "Bubbling Up" the Largest Element Traverse a collection of elements Move from the front to the end Bubble the largest value to the end using pairwise comparisons and swapping

6 "Bubbling Up" the Largest Element Traverse a collection of elements Move from the front to the end Bubble the largest value to the end using pairwise comparisons and swapping "Bubbling Up" the Largest Element Traverse a collection of elements Move from the front to the end Bubble the largest value to the end using pairwise comparisons and swapping

7 "Bubbling Up" the Largest Element Traverse a collection of elements Move from the front to the end Bubble the largest value to the end using pairwise comparisons and swapping No need to swap "Bubbling Up" the Largest Element Traverse a collection of elements Move from the front to the end Bubble the largest value to the end using pairwise comparisons and swapping

8 "Bubbling Up" the Largest Element Traverse a collection of elements Move from the front to the end Bubble the largest value to the end using pairwise comparisons and swapping Largest value correctly placed The Bubble Up Algorithm Bubble-Sort-step1( A ): for k = 1 (N 1): if A[k] > A[k+1]: ( A, k, k+1 ) ( A, x, y ): tmp = A[x] A[x] = A[y] A[y] = tmp 8

9 Need More Iterations Notice that only the largest value is correctly placed All other values are still out of order So we need to repeat this process Largest value correctly placed Repeat Bubble Up How Many Times? If we have N elements And if each time we bubble an element, we place it in its correct location Then we repeat the bubble up process N 1 times. This guarantees we ll correctly place all N elements. 9

10 N - 1 2/1/2016 Bubbling All the Elements The Bubble Up Algorithm Bubble-Sort( A ): for k = 1 (N 1): if A[k] > A[k+1]: ( A, k, k+1 ) 10

11 Inner loop Outer loop 2/1/2016 The Bubble Up Algorithm Bubble-Sort( A ): for i = 1 (N 1): for k = 1 (N 1): if A[k] > A[k+1]: ( A, k, k+1 ) The Bubble Up Algorithm Bubble-Sort( A ): for i = 1 (N 1): To do N-1 iterations To bubble a value for k = 1 (N 1): if A[k] > A[k+1]: ( A, k, k+1 ) 11

12 Reducing the Number of Comparisons Reducing the Number of Comparisons Assume the array size N On the i th iteration, we only need to do N-i comparisons. For example: N = 6 i = 4 (4 th iteration) Thus, we have 2 comparisons to do

13 The Bubble Up Algorithm Bubble-Sort( A ): for i = 1 (N 1): for k = 1 (N 1): if A[k] > A[k+1]: ( A, k, k+1 ) The Bubble Up Algorithm Bubble-Sort( A ): for i = 1 (N 1): for k = 1 (N i): if A[k] > A[k+1]: ( A, k, k+1 ) 13

14 Code Demo An Animated Example i 1 k

15 An Animated Example i 1 k An Animated Example i 1 k

16 An Animated Example i 1 k An Animated Example i 1 k

17 An Animated Example i 1 k An Animated Example i 1 k

18 An Animated Example i 1 k An Animated Example i 1 k

19 An Animated Example i 1 k An Animated Example i 1 k

20 An Animated Example i 1 k An Animated Example i 1 k

21 An Animated Example i 1 k An Animated Example i 1 k

22 An Animated Example i 1 k An Animated Example i 1 k

23 An Animated Example i 1 k An Animated Example i 1 k

24 An Animated Example i 1 k An Animated Example i 1 k

25 An Animated Example i 1 k After First Pass of Outer Loop i 1 k 8 Finished first Bubble Up

26 The Second Bubble Up i 2 k The Second Bubble Up i 2 k 1 No

27 The Second Bubble Up i 2 k The Second Bubble Up i 2 k

28 The Second Bubble Up i 2 k The Second Bubble Up i 2 k

29 The Second Bubble Up i 2 k The Second Bubble Up i 2 k

30 The Second Bubble Up i 2 k The Second Bubble Up i 2 k 4 No

31 The Second Bubble Up i 2 k The Second Bubble Up i 2 k

32 The Second Bubble Up i 2 k The Second Bubble Up i 2 k

33 The Second Bubble Up i 2 k The Second Bubble Up i 2 k

34 After Second Pass of Outer Loop i 2 k 7 Finished second Bubble Up The Third Bubble Up i 3 k

35 The Third Bubble Up i 3 k The Third Bubble Up i 3 k

36 The Third Bubble Up i 3 k The Third Bubble Up i 3 k

37 The Third Bubble Up i 3 k The Third Bubble Up i 3 k

38 The Third Bubble Up i 3 k 3 No The Third Bubble Up i 3 k

39 The Third Bubble Up i 3 k The Third Bubble Up i 3 k

40 The Third Bubble Up i 3 k The Third Bubble Up i 3 k

41 The Third Bubble Up i 3 k After Third Pass of Outer Loop i 3 k 6 Finished third Bubble Up

42 The Fourth Bubble Up i 4 k The Fourth Bubble Up i 4 k

43 The Fourth Bubble Up i 4 k The Fourth Bubble Up i 4 k

44 The Fourth Bubble Up i 4 k 2 No The Fourth Bubble Up i 4 k

45 The Fourth Bubble Up i 4 k 3 No The Fourth Bubble Up i 4 k

46 The Fourth Bubble Up i 4 k 4 No After Fourth Pass of Outer Loop i 4 k 5 Finished fourth Bubble Up

47 The Fifth Bubble Up i 5 k The Fifth Bubble Up i 5 k 1 No

48 The Fifth Bubble Up i 5 k The Fifth Bubble Up i 5 k 2 No

49 The Fifth Bubble Up i 5 k The Fifth Bubble Up i 5 k 3 No

50 After Fifth Pass of Outer Loop i 5 k 4 Finished fifth Bubble Up i 5 k

51 Inner loop Outer loop 2/1/2016 Analysis of Bubble Sort and Loop Invariant Bubble Sort Algorithm Bubble-Sort( A ): for i = 1 (N 1): To do N-1 iterations To bubble a value for k = 1 (N 1): if A[k] > A[k+1]: ( A, k, k+1 ) 51

52 Inner loop Inner loop Outer loop Outer loop 2/1/2016 Loop Invariant It is a condition or property that is guaranteed to be correct with each iteration in the loop Usually used to prove the correctness of the algorithm for i = 1 (N 1): To do N-1 iterations To bubble a value for k = 1 (N 1): if A[k] > A[k+1]: ( A, k, k+1 ) Loop Invariant for Bubble Sort for i = 1 (N 1): To do N-1 iterations To bubble a value for k = 1 (N 1): if A[k] > A[k+1]: ( A, k, k+1 ) By the end of iteration i the right-most i items (largest) are sorted and in place 52

53 N - 1 2/1/2016 N-1 Iterations st 2 nd 3 rd 4 th 5 th Correctness of Bubble Sort (using Loop Invariant) Bubble sort has N-1 Iterations Invariant: By the end of iteration i the right-most i items (largest) are sorted and in place Then: After the N-1 iterations The rightmost N-1 items are sorted This implies that all the N items are sorted 53

54 Bubble Sort Time Complexity Best-Case Time Complexity The scenario under which the algorithm will do the least amount of work (finish the fastest) What if we had a pass and nothing was swapped? What does that tell us? Worst-Case Time Complexity The scenario under which the algorithm will do the largest amount of work (finish the slowest) Summary Bubble Up algorithm will move largest value to its correct location (to the right) Repeat Bubble Up until all elements are correctly placed: Maximum of N-1 times Can finish early if no swapping occurs We reduce the number of elements we compare each time one is correctly placed Not the most efficient algorithm around but is easy to understand 54