Chapter 10

1. Chapter 10 Sorting Algorithms Data Structures Using C++

2. Chapter Objectives • Learn the various sorting algorithms • Explore how to implement the selection, insertion, quick, merge, and heap sorting algorithms • Discover how the sorting algorithms discussed in this chapter perform Data Structures Using C++

3. Selection Sort • Sorts list by • Finding smallest (or equivalently largest) element in the list • Moving it to the beginning (or end) of the list by swapping it with element in beginning (or end) position Data Structures Using C++

4. Smallest Element in List Function template<class elemType> int orderedArrayListType<elemType>::minLocation(int first, int last) { int loc, minIndex; minIndex = first; for(loc = first + 1; loc <= last; loc++) if(list[loc] < list[minIndex]) minIndex = loc; return minIndex; }//end minLocation Data Structures Using C++

5. Swap Function template<class elemType> void orderedArrayListType<elemType>::swap(int first, int second) { elemType temp; temp = list[first]; list[first] = list[second]; list[second] = temp; }//end swap Data Structures Using C++

6. Selection Sort Function template<class elemType> void orderedArrayListType<elemType>::selectionSort() { int loc, minIndex; for(loc = 0; loc < length - 1; loc++) { minIndex = minLocation(loc, length - 1); swap(loc, minIndex); } } Data Structures Using C++

7. Selection Sort Example: Array-Based Lists Data Structures Using C++

8. Selection Sort Example: Array-Based Lists Data Structures Using C++

9. Selection Sort Example: Array-Based Lists Data Structures Using C++

10. Selection Sort Example: Array-Based Lists Data Structures Using C++

11. Analysis: Selection Sort By analyzing the number of key comparisons, we see that selection sort is an O(n2) algorithm: Data Structures Using C++

12. Insertion Sort • Reduces number of key comparisons made in selection sort • Can be applied to both arrays and linked lists (examples follow) • Sorts list by • Finding first unsorted element in list • Moving it to its proper position Data Structures Using C++

13. Insertion Sort: Array-Based Lists Data Structures Using C++

14. Insertion Sort: Array-Based Lists Data Structures Using C++

15. Insertion Sort: Array-Based Lists Data Structures Using C++

16. Insertion Sort: Array-Based Lists Data Structures Using C++

17. Insertion Sort: Array-Based Lists for(firstOutOfOrder = 1; firstOutOfOrder < length; firstOutOfOrder++) if(list[firstOutOfOrder] is less than list[firstOutOfOrder - 1]) { copy list[firstOutOfOrder] into temp initialize location to firstOutOfOrder do { a. move list[location - 1] one array slot down b. decrement location by 1 to consider the next element of the sorted portion of the array } while(location > 0 && the element in the upper sublist at location - 1 is greater than temp) } copy temp into list[location] Data Structures Using C++

18. Insertion Sort: Array-Based Lists Data Structures Using C++

19. Insertion Sort: Array-Based Lists (after skipping a step) Data Structures Using C++

20. Insertion Sort: Array-Based Lists template<class elemType> void orderedArrayListType<elemType>::insertionSort() { int firstOutOfOrder, location; elemType temp; for(firstOutOfOrder = 1; firstOutOfOrder < length; firstOutOfOrder++) if(list[firstOutOfOrder] < list[firstOutOfOrder - 1]) { temp = list[firstOutOfOrder]; location = firstOutOfOrder; do { list[location] = list[location - 1]; location--; } while(location > 0 && list[location - 1] > temp); list[location] = temp; } }//end insertionSort Data Structures Using C++

21. Insertion Sort: Linked List-Based Data Structures Using C++

22. Insertion Sort: Linked List-Based if(firstOutOfOrder->info is less than first->info) move firstOutOfOrder before first else { set trailCurrent to first set current to the second node in the list //search the list while(current->info is less than firstOutOfOrder->info) { advance trailCurrent; advance current; } if(current is not equal to firstOutOfOrder) { //insert firstOutOfOrder between current and trailCurrent lastInOrder->link = firstOutOfOrder->link; firstOutOfOrder->link = current; trailCurrent->link = firstOutOfOrder; } else //firstOutOfOrder is already at the first place lastInOrder = lastInOrder->link; } Data Structures Using C++

23. Analysis: Insertion Sort What are worst case complexities of each? Best case? Data Structures Using C++

24. Lower Bound on Comparison-Based Sort Algorithms • Trace execution of comparison-based algorithm by using graph called comparison tree • Let L be a list of n distinct elements, where n > 0. For any j and k, either L[j] < L[k] or L[j] > L[k] • Each comparison of the keys has two outcomes; comparison tree is a binary tree • Each comparison is a node • Node is labeled as j:k, representing comparison of L[j] with L[k] • If L[j] < L[k], follow the left branch; otherwise, follow the right branch Data Structures Using C++

25. Lower Bound on Comparison-Based Sort Algorithms Data Structures Using C++

26. Lower Bound on Comparison-Based Sort Algorithms • Each leaf represents a different final ordering of the input • n inputs implies n! leaves • Since any initial ordering of inputs is possible, all paths through comparison tree are possible • Worst-case number of comparisons = length of longest path from root to any leaf • Binary tree of height h has at most 2h nodes, so 2h > n! • Thus h > log2n! > log2 (n/3)n = n log2 (n/3) = Ω(n logn) • Theorem: Let L be a list of n distinct elements. Any sorting algorithm that sorts L by comparison of the keys only, in the worst case, makes at least Ω(n logn) key comparisons Data Structures Using C++

27. Quick Sort • Recursive algorithm • Uses “divide-and-conquer” • List L is partitioned into two sublists, and the two sublists are then sorted and combined into one list in such a way so that the combined list is sorted • Choose a pivot element to partition the list such that everything in the “lower” list is < pivot and everything in the “upper” list is > pivot • Once lower and upper lists are sorted, L is sorted trivially Data Structures Using C++

28. Quick Sort: Array-Based Lists Data Structures Using C++

29. Quick Sort: Array-Based Lists • Start with pivot=0 (first position), smallIndex=0, index=1 • Loop index through the list • If L[index] < L[pivot], increment smallIndex and swap L[index] with L[smallIndex] • Swap L[pivot] with L[smallIndex] Data Structures Using C++

30. Quick Sort: Array-Based Lists pivot smallIndex index Data Structures Using C++

31. Quick Sort: Array-Based Lists Data Structures Using C++

32. Quick Sort: Array-Based Lists Data Structures Using C++

33. Quick Sort: Array-Based Lists Data Structures Using C++

34. Quick Sort: Array-Based Lists template<class elemType> int orderedArrayListType<elemType>::partition(int first, int last) { elemType pivot; int index, smallIndex; swap(first, (first + last)/2); pivot = list[first]; smallIndex = first; for(index = first + 1; index <= last; index++) if(list[index] < pivot) { smallIndex++; swap(smallIndex, index); } swap(first, smallIndex); return smallIndex; } Data Structures Using C++

35. Quick Sort: Array-Based Lists template<class elemType> void orderedArrayListType<elemType>::swap(int first,int second) { elemType temp; temp = list[first]; list[first] = list[second]; list[second] = temp; } //end swap Data Structures Using C++

36. Quick Sort: Array-Based Lists template<class elemType> void orderedArrayListType<elemType>::recQuickSort(int first, int last) { int pivotLocation; if(first <last) { pivotLocation = partition(first, last); recQuickSort(first, pivotLocation - 1); recQuickSort(pivotLocation + 1, last); } } //end recQuickSort template<class elemType> void orderedArrayListType<elemType>::quickSort() { recQuickSort(0, length - 1); }//end quickSort Data Structures Using C++

37. Quick Sort Analysis Data Structures Using C++

38. Merge Sort • Uses the divide-and-conquer technique to sort a list • Merge sort algorithm also partitions the list into two sublists, sorts the sublists, and then combines the sorted sublists into one sorted list • Merging two sorted lists into a single sorted list is easy and fast Data Structures Using C++

39. Merge Sort Algorithm Data Structures Using C++

40. Divide Data Structures Using C++

41. Divide Data Structures Using C++

42. Merge Data Structures Using C++

43. Merge Data Structures Using C++

44. Analysis of Merge Sort Suppose that L is a list of n elements, where n > 0. Let A(n) denote the number of key comparisons in the average case, and W(n) denote the number of key comparisons in the worst case to sort L. It can be shown that: A(n) = n log2n – 1.26 n = O(n log n) W(n) = n log2n – (n – 1) = O(n log n) Data Structures Using C++

45. Heap Sort • Definition: A heap is a list in which each element contains a key, such that the key in the element at position k in the list is at least as large as the key in the element at position 2k + 1 (if it exists), and 2k + 2 (if it exists) • Can also represent as a binary tree where a node is > than both its children • Heap sort builds a heap out of a list (bottom-up), then pulls (max) items off the top, one at a time Data Structures Using C++

46. Heap Sort: Array-Based Lists Data Structures Using C++

47. Heap Sort: Array-Based Lists Check if heap Data Structures Using C++

48. Heap Sort: Array-Based Lists Data Structures Using C++

49. Heap Sort: Array-Based Lists Data Structures Using C++

50. Heap Sort: Array-Based Lists Data Structures Using C++