1. Sorting Sorting Arranging items in a collection so that there is an ordering on one (or more) of the fields in the items Sort Key The field (or fields) on which the ordering is based Sorting algorithms Algorithms that order the items in the collection based on the sort key Why is sorting important?

2.  Chapter 13 presents several common algorithms for sorting an array of integers.  Two slow but simple algorithms are Selectionsort and Insertionsort.  This presentation demonstrates how the two algorithms work. Quadratic Sorting Data Structures and Other Objects Using C++

3. Selection Sort Given a list of names, put them in alphabetical order  Find the name that comes first in the alphabet, and write it on a second sheet of paper  Cross out the name off the original list  Continue this cycle until all the names on the original list have been crossed out and written onto the second list, at which point the second list contains the same items but in sorted order

4. Selection Sort A slight adjustment to this manual approach does away with the need to duplicate space  As you cross a name off the original list, a free space opens up  Instead of writing the value found on a second list, exchange it with the value currently in the position where the crossed-off item should go

5. Selection Sort Figure 9.9 Example of a selection sort (sorted elements are shaded)

6. Sorting an Array of Integers   The picture shows an array of six integers that we want to sort from smallest to largest [0] [1] [2] [3] [4] [5]

7. The Selectionsort Algorithm   Start by finding the smallest entry. [0] [1] [2] [3] [4] [5]

8. The Selectionsort Algorithm   Start by finding the smallest entry.   Swap the smallest entry with the first entry. [0] [1] [2] [3] [4] [5]

9. The Selectionsort Algorithm   Start by finding the smallest entry.   Swap the smallest entry with the first entry. [0] [1] [2] [3] [4] [5]

10. The Selectionsort Algorithm   Part of the array is now sorted. Sorted side Unsorted side [0] [1] [2] [3] [4] [5]

11. The Selectionsort Algorithm   Find the smallest element in the unsorted side. Sorted side Unsorted side [0] [1] [2] [3] [4] [5]

12. The Selectionsort Algorithm   Find the smallest element in the unsorted side.   Swap with the front of the unsorted side. Sorted side Unsorted side [0] [1] [2] [3] [4] [5]

13. The Selectionsort Algorithm   We have increased the size of the sorted side by one element. Sorted side Unsorted side [0] [1] [2] [3] [4] [5]

14. The Selectionsort Algorithm   The process continues... Sorted side Unsorted side Smallest from unsorted [0] [1] [2] [3] [4] [5]

15. The Selectionsort Algorithm   The process continues... Sorted side Unsorted side [0] [1] [2] [3] [4] [5] Swap with front

16. The Selectionsort Algorithm   The process continues... Sorted side Unsorted side Sorted side is bigger [0] [1] [2] [3] [4] [5]

17. The Selectionsort Algorithm   The process keeps adding one more number to the sorted side.   The sorted side has the smallest numbers, arranged from small to large. Sorted side Unsorted side [0] [1] [2] [3] [4] [5]

18. The Selectionsort Algorithm   We can stop when the unsorted side has just one number, since that number must be the largest number. [0] [1] [2] [3] [4] [5] Sorted side Unsorted side

19. The Selectionsort Algorithm   The array is now sorted.   We repeatedly selected the smallest element, and moved this element to the front of the unsorted side. [0] [1] [2] [3] [4] [5]

20. The Insertionsort Algorithm   The Insertionsort algorithm also views the array as having a sorted side and an unsorted side. [0] [1] [2] [3] [4] [5]

21. The Insertionsort Algorithm   The sorted side starts with just the first element, which is not necessarily the smallest element. [0] [1] [2] [3] [4] [5] Sorted side Unsorted side

22. The Insertionsort Algorithm   The sorted side grows by taking the front element from the unsorted side... Sorted side Unsorted side cur i=1 for (int i = 1; i < v.size(); i++) { int cur = v[i]; // slide cur down into position to left

23. The Insertionsort Algorithm  ...and inserting it in the place that keeps the sorted side arranged from small to large. Sorted side Unsorted side j=i-1 i=1 for (int j=i-1; j >= 0 && v[j] > cur; j--) v[j+1] = v[j]; cur

24. The Insertionsort Algorithm   In this example, the new element goes in front of the element that was already in the sorted side. Sorted side Unsorted side for (int j=i-1; j >= 0 && v[j] > cur; j--) v[j+1] = v[j]; v[j+1] = cur; j-- j+1=0

25. The Insertionsort Algorithm   Sometimes we are lucky and the new inserted item doesn't need to move at all. Sorted side Unsorted side for (int i = 1; i < v.size(); i++) { int cur = v[i]; // slide cur down into position to left

26. The Insertionsort Algorithm   Sometimes we are lucky twice in a row. Sorted side Unsorted side v[j+1] = cur; for (int j=i-1; j >= 0 && v[j] > cur; j--) v[j+1] = v[j];

27. How to Insert One Element   Copy the new element to a separate location. Sorted side Unsorted side cur for (int j=i-1; j >= 0 && v[j] > cur; j--) v[j+1] = v[j];

28. How to Insert One Element   Shift elements in the sorted side, creating an open space for the new element. for (int j=i-1; j >= 0 && v[j] > cur; j--) v[j+1] = v[j];

29. How to Insert One Element   Shift elements in the sorted side, creating an open space for the new element. for (int j=i-1; j >= 0 && v[j] > cur; j--) v[j+1] = v[j];

30. How to Insert One Element   Continue shifting elements... for (int j=i-1; j >= 0 && v[j] > cur; j--) v[j+1] = v[j];

31. How to Insert One Element   Continue shifting elements... for (int j=i-1; j >= 0 && v[j] > cur; j--) v[j+1] = v[j];

32. How to Insert One Element  ...until you reach the location for the new element. for (int j=i-1; j >= 0 && v[j] > cur; j--) v[j+1] = v[j];

33. How to Insert One Element   Copy the new element back into the array, at the correct location. Sorted side Unsorted side v[j+1] = cur;

34. How to Insert One Element  The last element must also be inserted. Start by copying it... [0] [1] [2] [3] [4] [5] Sorted side Unsorted side

35. Bubble Sort Bubble Sort uses the same strategy: Find the next item Put it into its proper place But uses a different scheme for finding the next item Starting with the last list element, compare successive pairs of elements, swapping whenever the bottom element of the pair is smaller than the one above it

36. Bubble Sort Figure 9.10 Example of a bubble sort

37. Algorithms Can you write the algorithms for the selection sort and the bubble sort? Can you think of a way to make the bubble sort more efficient?

38. Logarithmic Sorting * Quick Sort * Merge Sort

39. Quicksort Figure 9.12 Ordering a list using the Quicksort algorithm It is easier to sort a smaller number of items: Sort A…F, G…L, M…R, and S…Z and A…Z is sorted

40. Quicksort If (there is more than one item in list[first]..list[last]) Select splitVal Split the list so that list[first]..list[splitPoint-1] <= splitVal list[splitPoint] = splitVal list[splitPoint+1]..list[last] > splitVal Quicksort the left half Quicksort the right half

41. Quicksort

42. Split Set left to first + 1 Set right to last Do Increment left until list[left] > splitVal OR left > right Decrement right until list[right] right If (left < right) Swap list[left] and list[right] While (left <= right) Set splitPoint to right Swap list[first] and last[right]

43. Quicksort Figure 9.13 Splitting algorithm

44. Quick Sort Code  void Quicksort(Vector &v, int start, int stop) {  if (stop > start) { //base case  int pivot = Partition(v, start, stop); //partition  Quicksort(v, start, pivot-1); //recursive sort left  Quicksort(v, pivot+1, stop);//recursive sort right  }

45. Partition Code – set up pivot  int Partition(vector & arr, int start, int stop)  { int lh = start + 1; //left hand  int rh = stop; //right hand  int pivot; //variable to hold pivot  pivot = arr[start]; //set pivot to first element

46. Partition Code—Move to center  while(true) {  while(lh = pivot) rh--;  while(lh <rh && arr[lh] < pivot) lh++;  if(lh == rh) break; //base case

47. Partition Code—Swap  while(true) {  while(lh = pivot) rh--;  while(lh <rh && arr[lh] < pivot) lh++;  if(lh == rh) break; //base case  swap(arr[lh], arr[rh]);  }

48. Partition Code—Left Overs?  if(arr[lh] >= pivot) return start; swap(arr[start], arr[lh]; return lh;  } //end Partition function

49. Merge Sort—Partition 8 7 4 3 9 5 10

50. Merge Sort—Partition 8 7 4 3 9 5 10

51. Merge Sort—Partition 8 7 9 54 3 10

52. Merge Sort—Merge 8 94 10 7 3 5 Compare -- smallest goes first

53. Merge Sort—Merge 8 94 10 7 3 5 Compare -- smallest goes first

54. Merge Sort—Merge 8 94 10 73 5 Compare -- smallest goes first

55. Merge Sort—Merge 8 94 10 73 5 Compare -- smallest goes first

56. Merge Sort—Merge 8 94 10 73 5 Compare -- smallest goes first

57. Merge Sort—Merge 8 9 4 10 7 3 5 Compare -- smallest goes first

58. Merge Sort—Merge 8 9 4 10 7 3 5 Compare -- smallest goes first

59. Merge Sort—Merge 8 9 4 10 7 3 5 Compare -- smallest goes first

60. Merge Sort—Merge 8 9 4 10 7 3 5

61. Merge Sort—Merge 8 94 10 7 3 5 Compare –smallest goes first Compare—smallest goes first Choose smallest from each stack

62. Merge Sort—Merge 8 94 10 7 35 Compare –smallest goes first Compare—smallest goes first Choose smallest from each stack

63. Merge Sort—Merge 8 94 10 7 35 Compare –smallest first Compare --smallest first

64. Merge Sort—Merge 8 94 10 7 35 Compare –smallest first

65. Merge Sort—Merge 8 94 10 7 35 Compare –smallest goes first

66. Merge Sort—Merge 8 94 10 7 3 5 Compare –smallest first

67. Merge Sort—Merge 8 9 4 10 7 3 5 Compare –smallest first

68. Merge Sort—Merge 8 9 4 10 7 3 5 Compare –smallest first

69. Merge Sort—Merge 8 9 4 10 7 35 Compare—smallest first

70. Merge Sort—Merge 8 9 4 10 7 35 Compare –smallest first

71. Merge Sort—Merge 8 9 4 10 7 35 Compare –smallest first

72. Merge Sort—Merge 8 9 4 10 7 35 Compare –smallest first The remainders

73. Merge Sort—Merge 894 10 7 35 The remainders

74. Merge Sort—Done 894 10 7 35

75. A Quiz How many shifts will occur before we copy this element back into the array? [0] [1] [2] [3] [4] [5]

76. A Quiz  Four items are shifted. [0] [1] [2] [3] [4] [5]

77. A Quiz  Four items are shifted.  And then the element is copied back into the array. [0] [1] [2] [3] [4] [5]

78.  Both Selectionsort and Insertionsort have a worst- case time of O(n 2 ), making them impractical for large arrays.  But they are easy to program, easy to debug.  Insertionsort also has good performance when the array is nearly sorted to begin with.  But more sophisticated sorting algorithms are needed when good performance is needed in all cases for large arrays. Timing and Other Issues

79. T HE E ND Presentation copyright 2004 Addison Wesley Longman, For use with Data Structures and Other Objects Using C++ by Michael Main and Walter Savitch. Some artwork in the presentation is used with permission from Presentation Task Force (copyright New Vision Technologies Inc) and Corel Gallery Clipart Catalog (copyright Corel Corporation, 3G Graphics Inc, Archive Arts, Cartesia Software, Image Club Graphics Inc, One Mile Up Inc, TechPool Studios, Totem Graphics Inc). Students and instructors who use Data Structures and Other Objects Using C++ are welcome to use this presentation however they see fit, so long as this copyright notice remains intact.