1. Sorting
Chapter 9

2. Objectives
Selection Sort,
Insertion Sort,
Quick Sort, and
Merge Sort.

3. Introduction
Common problem: sort a list of values, starting from lowest to highest.
– Telephone directory
– Words of dictionary in alphabetical order
– Students names listed alphabetically
Choose a criteria which is used to order data
Given a list of records that have keys, we use these keys to define an ordering of the items in the list.

4. Example 1

5. The Insertion Sort Algorithm
Given an array of integers
The Insertion Sort algorithm views the array as having a sorted side and an unsorted side.
The sorted side starts with just the first element, which is not necessarily the smallest element.
The sorted side grows by taking the front element from the unsorted side.

7. Example 2

8. Example 3

9. Example 4

10. The Selection Sort Algorithm
Start by finding the smallest element.
Swap the smallest entry with the first element.
Part of the array is sorted.
Find the smallest element in the unsorted side.
Swap with the front of the unsorted side.
The size of the sorted side is increased by one element.
Continue until the unsorted side has just one number. Why?

11. The Selection Sort Algorithm (cont.)

12. Example 1

13. Example 2

14. Quick sort Algorithm Given an array of n elements (e.g., integers):
􀂄 If array only contains one element, return
􀂄 Else
pick one element to use as pivot.
Partition elements into two sub-arrays:
Elements less than or equal to pivot
Elements greater than pivot
Quick sort two sub-arrays
Return results

15. Pick

17. Total comparisons Assume that keys are random, uniformly distributed.
Best case running time: O(n log2n)
Worst case running time: O(n2)!!!

18. Quick sort: Worst Case

19. Partitioning Array
Given a pivot, partition the elements of the array such that the resulting array consists of:
One sub-array that contains elements >= pivot
Another sub-array that contains elements < pivot
The sub-arrays are stored in the original data array.
Partitioning loops through, swapping elements below/above pivot.

20. Example 1 40 20 10 80 60 50 7 30
100
pivot_index = 0
[0] [1] [2] [3] [4] [5] [6] [7] [8]
too_big_index
too_small_index

21. While data[too_big_index] <= data[pivot]40 20 10 80 60 50 7 30
100
pivot_index = 0
[0] [1] [2] [3] [4] [5] [6] [7] [8]
too_big_index
too_small_index

22. While data[too_big_index] <= data[pivot]40 20 10 80 60 50 7 30
100
pivot_index = 0
[0] [1] [2] [3] [4] [5] [6] [7] [8]
too_big_index
too_small_index

23. While data[too_big_index] <= data[pivot]40 20 10 80 60 50 7 30
100
pivot_index = 0
[0] [1] [2] [3] [4] [5] [6] [7] [8]
too_big_index
too_small_index

24. While data[too_big_index] <= data[pivot]
While data[too_small_index] > data[pivot]
--too_small_index 40 20 10 80 60 50 7 30
100
pivot_index = 0
[0] [1] [2] [3] [4] [5] [6] [7] [8]
too_big_index
too_small_index

25. While data[too_big_index] <= data[pivot]
While data[too_small_index] > data[pivot]
--too_small_index 40 20 10 80 60 50 7 30
100
pivot_index = 0
[0] [1] [2] [3] [4] [5] [6] [7] [8]
too_big_index
too_small_index

26. While data[too_big_index] <= data[pivot]
While data[too_small_index] > data[pivot]
--too_small_index
If too_big_index < too_small_index
swap data[too_big_index] and data[too_small_index] 40 20 10 80 60 50 7 30
100
pivot_index = 0
[0] [1] [2] [3] [4] [5] [6] [7] [8]
too_big_index
too_small_index

27. While data[too_big_index] <= data[pivot]
While data[too_small_index] > data[pivot]
--too_small_index
If too_big_index < too_small_index
swap data[too_big_index] and data[too_small_index] 40 20 10 30 60 50 7 80
100
pivot_index = 0
[0] [1] [2] [3] [4] [5] [6] [7] [8]
too_big_index
too_small_index

28. While data[too_big_index] <= data[pivot]
While data[too_small_index] > data[pivot]
--too_small_index
If too_big_index < too_small_index
swap data[too_big_index] and data[too_small_index]
While too_small_index > too_big_index, go to 1. 40 20 10 30 60 50 7 80
100
pivot_index = 0
[0] [1] [2] [3] [4] [5] [6] [7] [8]
too_big_index
too_small_index

29. While data[too_big_index] <= data[pivot]
While data[too_small_index] > data[pivot]
--too_small_index
If too_big_index < too_small_index
swap data[too_big_index] and data[too_small_index]
While too_small_index > too_big_index, go to 1. 40 20 10 30 60 50 7 80
100
pivot_index = 0
[0] [1] [2] [3] [4] [5] [6] [7] [8]
too_big_index
too_small_index

30. While data[too_big_index] <= data[pivot]
While data[too_small_index] > data[pivot]
--too_small_index
If too_big_index < too_small_index
swap data[too_big_index] and data[too_small_index]
While too_small_index > too_big_index, go to 1. 40 20 10 30 60 50 7 80
100
pivot_index = 0
[0] [1] [2] [3] [4] [5] [6] [7] [8]
too_big_index
too_small_index

31. While data[too_big_index] <= data[pivot]
While data[too_small_index] > data[pivot]
--too_small_index
If too_big_index < too_small_index
swap data[too_big_index] and data[too_small_index]
While too_small_index > too_big_index, go to 1. 40 20 10 30 60 50 7 80
100
pivot_index = 0
[0] [1] [2] [3] [4] [5] [6] [7] [8]
too_big_index
too_small_index

32. While data[too_big_index] <= data[pivot]
While data[too_small_index] > data[pivot]
--too_small_index
If too_big_index < too_small_index
swap data[too_big_index] and data[too_small_index]
While too_small_index > too_big_index, go to 1. 40 20 10 30 60 50 7 80
100
pivot_index = 0
[0] [1] [2] [3] [4] [5] [6] [7] [8]
too_big_index
too_small_index

33. While data[too_big_index] <= data[pivot]
While data[too_small_index] > data[pivot]
--too_small_index
If too_big_index < too_small_index
swap data[too_big_index] and data[too_small_index]
While too_small_index > too_big_index, go to 1. 40 20 10 30 60 50 7 80
100
pivot_index = 0
[0] [1] [2] [3] [4] [5] [6] [7] [8]
too_big_index
too_small_index

34. While data[too_big_index] <= data[pivot]
While data[too_small_index] > data[pivot]
--too_small_index
If too_big_index < too_small_index
swap data[too_big_index] and data[too_small_index]
While too_small_index > too_big_index, go to 1. 40 20 10 30 7 50 60 80
100
pivot_index = 0
[0] [1] [2] [3] [4] [5] [6] [7] [8]
too_big_index
too_small_index

35. While data[too_big_index] <= data[pivot]
While data[too_small_index] > data[pivot]
--too_small_index
If too_big_index < too_small_index
swap data[too_big_index] and data[too_small_index]
While too_small_index > too_big_index, go to 1. 40 20 10 30 7 50 60 80
100
pivot_index = 0
[0] [1] [2] [3] [4] [5] [6] [7] [8]
too_big_index
too_small_index

36. While data[too_big_index] <= data[pivot]
While data[too_small_index] > data[pivot]
--too_small_index
If too_big_index < too_small_index
swap data[too_big_index] and data[too_small_index]
While too_small_index > too_big_index, go to 1. 40 20 10 30 7 50 60 80
100
pivot_index = 0
[0] [1] [2] [3] [4] [5] [6] [7] [8]
too_big_index
too_small_index

37. While data[too_big_index] <= data[pivot]
While data[too_small_index] > data[pivot]
--too_small_index
If too_big_index < too_small_index
swap data[too_big_index] and data[too_small_index]
While too_small_index > too_big_index, go to 1. 40 20 10 30 7 50 60 80
100
pivot_index = 0
[0] [1] [2] [3] [4] [5] [6] [7] [8]
too_big_index
too_small_index

38. While data[too_big_index] <= data[pivot]
While data[too_small_index] > data[pivot]
--too_small_index
If too_big_index < too_small_index
swap data[too_big_index] and data[too_small_index]
While too_small_index > too_big_index, go to 1. 40 20 10 30 7 50 60 80
100
pivot_index = 0
[0] [1] [2] [3] [4] [5] [6] [7] [8]
too_big_index
too_small_index

39. While data[too_big_index] <= data[pivot]
While data[too_small_index] > data[pivot]
--too_small_index
If too_big_index < too_small_index
swap data[too_big_index] and data[too_small_index]
While too_small_index > too_big_index, go to 1. 40 20 10 30 7 50 60 80
100
pivot_index = 0
[0] [1] [2] [3] [4] [5] [6] [7] [8]
too_big_index
too_small_index

40. While data[too_big_index] <= data[pivot]
While data[too_small_index] > data[pivot]
--too_small_index
If too_big_index < too_small_index
swap data[too_big_index] and data[too_small_index]
While too_small_index > too_big_index, go to 1. 40 20 10 30 7 50 60 80
100
pivot_index = 0
[0] [1] [2] [3] [4] [5] [6] [7] [8]
too_big_index
too_small_index

41. While data[too_big_index] <= data[pivot]
While data[too_small_index] > data[pivot]
--too_small_index
If too_big_index < too_small_index
swap data[too_big_index] and data[too_small_index]
While too_small_index > too_big_index, go to 1. 40 20 10 30 7 50 60 80
100
pivot_index = 0
[0] [1] [2] [3] [4] [5] [6] [7] [8]
too_big_index
too_small_index

42. While data[too_big_index] <= data[pivot]
While data[too_small_index] > data[pivot]
--too_small_index
If too_big_index < too_small_index
swap data[too_big_index] and data[too_small_index]
While too_small_index > too_big_index, go to 1. 40 20 10 30 7 50 60 80
100
pivot_index = 0
[0] [1] [2] [3] [4] [5] [6] [7] [8]
too_big_index
too_small_index

43. While data[too_big_index] <= data[pivot]
While data[too_small_index] > data[pivot]
--too_small_index
If too_big_index < too_small_index
swap data[too_big_index] and data[too_small_index]
While too_small_index > too_big_index, go to 1.
Swap data[too_small_index] and data[pivot_index] 40 20 10 30 7 50 60 80
100
pivot_index = 0
[0] [1] [2] [3] [4] [5] [6] [7] [8]
too_big_index
too_small_index

44. While data[too_big_index] <= data[pivot]
While data[too_small_index] > data[pivot]
--too_small_index
If too_big_index < too_small_index
swap data[too_big_index] and data[too_small_index]
While too_small_index > too_big_index, go to 1.
Swap data[too_small_index] and data[pivot_index] 7 20 10 30 40 50 60 80
100
pivot_index = 4
[0] [1] [2] [3] [4] [5] [6] [7] [8]
too_big_index
too_small_index

45. Partition Result 7 20 10 30 40 50 60 80
100
[0] [1] [2] [3] [4] [5] [6] [7] [8]
<= data[pivot]
> data[pivot]

46. Recursion: Quicksort Sub-arrays7 20 10 30 40 50 60 80
100
[0] [1] [2] [3] [4] [5] [6] [7] [8]
<= data[pivot]
> data[pivot]

47. Merge Sort Problem: Given n elements, sort elements
into non-decreasing order
Apply divide-and-conquer to sorting problem
If n=1 terminate (every one-element list is already sorted)
If n>1, partition elements into two sub-arrays; sort each; combine into a single sorted array
How do we partition?

48. Example 1 Partition into lists of size n/2 [10, 4, 6, 3, 8, 2, 5, 7]
[10, 4, 6, 3]
[8, 2, 5, 7]
[10, 4]
[6, 3]
[8, 2]
[5, 7]
[4] [10]
[3][6]
[2][8]
[5][7]

49. Example Cont’d Merge [2, 3, 4, 5, 6, 7, 8, 10 ] [3, 4, 6, 10]
[2, 5, 7, 8]
[4, 10]
[3, 6]
[2, 8]
[5, 7]
[4] [10]
[3][6]
[2][8]
[5][7]

50. Example 2