There are several common sorting algorithms: - Insertion sort is simple and in-place but slow, with O(n^2) time complexity. It builds up a sorted array from the start by inserting elements. - Merge sort divides the array into smaller sorted runs and then merges them back together, requiring additional memory but with optimal O(n log n) time. - Quicksort uses a pivot element and partitions the array into sub-arrays, recursively sorting them. It has O(n log n) average time and can be done in-place. - Heapsort uses a heap data structure represented as an array to sort in O(n log n) time by repeatedly extracting the maximum element

1. Sorting
Arvind Devaraj

2. Sorting
• Given an array, put the elements in order
– Numerical or lexicographic
• Desirable characteristics
– Fast
– In place (don’t need a second array)
– Stability

3. Insertion Sort
• Simple, able to handle any data
• Grow a sorted array from the beginning
– Create an empty array of the proper size
– Pick the elements one at a time in any order
– Put them in the new array in sorted order
• If the element is not last, make room for it
– Repeat until done
• Can be done in place if well designed

4. Insertion Sort
90 11 27 37111631 4

5. Insertion Sort
90 11 27 37111631 4
90

6. Insertion Sort
90 11 27 37111631 4
9011

7. Insertion Sort
90 11 27
90
37111631 4
2711

8. Insertion Sort
90 11 27
31 90
37111631 4
2711

9. Insertion Sort
90 11 27
27 31 90
37111631 4
114

10. Insertion Sort
90 11 27
16 27 31 90
37111631 4
114

11. Insertion Sort
90 11 27
11 16 27 31 90
37111631 4
114

12. Insertion Sort
90 11 27
11 16 27 31 37 90
37111631 4
114

13. Merge Sort
• Fast, able to handle any data
– But can’t be done in place
• View the array as a set of small sorted arrays
– Initially only the 1-element “arrays” are sorted
• Merge pairs of sorted arrays
– Repeatedly choose the smallest element in each
– This produces sorted arrays that are twice as long
• Repeat until only one array remains

14. Merge Sort
90 11 27 37111631 4
9011

15. Merge Sort
90 11 27
27 31
37111631 4
9011

16. Merge Sort
90 11 27
27 31 4 16
37111631 4
9011

17. Merge Sort
90 11 27
27 31 4 16 11 37
37111631 4
9011

18. Merge Sort
11 27 31
27 31 4 16 11 37
90
9011

19. Merge Sort
11 27 31
27 31 4 16 11 37
37161190 4
9011

20. Merge Sort
11 27 31
11 16 27 31 37 90
37161190 4
114

21. Divide and Conquer
• Split a problem into simpler subproblems
– Keep doing that until trivial subproblems result
• Solve the trivial subproblems
• Combine the results to solve a larger problem
– Keep doing that until the full problem is solved
• Merge sort illustrates divide and conquer
– But it is a general strategy that is often helpful

22. Quick Sort
• For example, given
80 38 95 84 99 10 79 44 26 87 96 12 43 81 3
we can select the middle entry, 44, and sort
the remaining entries into two groups, those
less than 44 and those greater than 44:
38 10 26 12 43 3 44 80 95 84 99 79 87 96 81
• If we sort each sub-list, we will have sorted
the entire array

23. A sample heap
• Each node is larger than its children
19
1418
22
321
14
119
15
25
1722

24. Sorting using Heaps
• What do heaps have to do with sorting an array?
Because the binary tree is balanced and left justified, it can be
represented as an array
– All our operations on binary trees can be represented as
operations on arrays
– To sort:
heapify the array;
while the array isn’t empty {
remove and replace the root;
reheap the new root node;
}

25. Summary of Sorting Algorithms
• in-place, randomized
• fastest (good for large inputs)
O(n log n)
expected
quick-sort
• sequential data access
• fast (good for huge inputs)
O(n log n)merge-sort
• in-place
• fast (good for large inputs)
O(n log n)heap-sort
O(n2)
O(n2)
Time
insertion-sort
selection-sort
Algorithm Notes
• in-place
• slow (good for small inputs)
• in-place
• slow (good for small inputs)