1. 10.3 Bubble Sort
Chapter 10 - Sorting

2. Attendance Quiz #34
Sorting

3. Tip #36: Assigning Container Values
Sorting
pair<int, int> p;
p = make_pair(3, 4);
p = {3, 4};
vector<int> v;
v.push_back(1); …
v = {1, 2, 5, 2};
deque<vector<pair<int, int>>> d;
d = {{{3, 4}, {5, 6}}, {{1, 2}, {3, 4}}};
set<int> s;
s = {4, 6, 2, 7, 4};
list<int> l;
l = {5, 6, 9, 1};
array<int, 4> a;
a = {5, 8, 9, 2};
tuple<int, int, char> t;
t = {3, 4, 'f'};

4. Analysis of Bubble Sort
Code for Bubble Sort
10.3, pgs

5. Bubble Sort Selection sort is relatively easy to understand.
Sorting
Selection sort is relatively easy to understand.
It sorts an array by making several passes through the array, selecting a next smallest item in the array each time and placing it where it belongs in the array.
Bubble sort is also a quadratic sort.
Compares adjacent array elements and exchanges their values if they are out of order.
Smaller values bubble up to the top of the array and larger values sink to the bottom; hence the name.

6. Trace of Bubble Sort do for each pair of adjacent array elements
Sorting do
for each pair of adjacent array elements
if the values in a pair are out of order
Exchange the values
while the array is not sorted 60 42 75 83 27
[0]
[1]
[2]
[3]
[4]

7. Trace of Bubble Sort do for each pair of adjacent array elements
Sorting
pass 1
exchanges made do
for each pair of adjacent array elements
if the values in a pair are out of order
Exchange the values
while the array is not sorted 60 42 75 83 27
[0]
[1]
[2]
[3]
[4]

8. Trace of Bubble Sort do for each pair of adjacent array elements
Sorting
pass 1
exchanges made do
for each pair of adjacent array elements
if the values in a pair are out of order
Exchange the values
while the array is not sorted 42 60 75 83 27
[0]
[1]
[2]
[3]
[4]

9. Trace of Bubble Sort do for each pair of adjacent array elements
Sorting
pass 1
exchanges made do
for each pair of adjacent array elements
if the values in a pair are out of order
Exchange the values
while the array is not sorted 42 60 75 83 27
[0]
[1]
[2]
[3]
[4]

10. Trace of Bubble Sort do for each pair of adjacent array elements
Sorting
pass 1
exchanges made do
for each pair of adjacent array elements
if the values in a pair are out of order
Exchange the values
while the array is not sorted 42 60 75 83 27
[0]
[1]
[2]
[3]
[4]

11. Trace of Bubble Sort do for each pair of adjacent array elements
Sorting
pass 1
exchanges made do
for each pair of adjacent array elements
if the values in a pair are out of order
Exchange the values
while the array is not sorted 42 60 75 83 27
[0]
[1]
[2]
[3]
[4]

12. Trace of Bubble Sort do for each pair of adjacent array elements
Sorting
pass 1
exchanges made 2 do
for each pair of adjacent array elements
if the values in a pair are out of order
Exchange the values
while the array is not sorted 42 60 75 27 83
[0]
[1]
[2]
[3]
[4]

13. Trace of Bubble Sort do for each pair of adjacent array elements
Sorting
pass 1
exchanges made 2 do
for each pair of adjacent array elements
if the values in a pair are out of order
Exchange the values
while the array is not sorted 42 60 75 27 83
[0]
[1]
[2]
[3]
[4]
At the end of pass 1, the last item (index [4]) is guaranteed to be in its correct position. There is no need to test it again in the next pass

14. Trace of Bubble Sort do for each pair of adjacent array elements
Sorting
pass 2
exchanges made do
for each pair of adjacent array elements
if the values in a pair are out of order
Exchange the values
while the array is not sorted 42 60 75 27 83
[0]
[1]
[2]
[3]
[4]

15. Trace of Bubble Sort do for each pair of adjacent array elements
Sorting
pass 2
exchanges made do
for each pair of adjacent array elements
if the values in a pair are out of order
Exchange the values
while the array is not sorted 42 60 75 27 83
[0]
[1]
[2]
[3]
[4]

16. Trace of Bubble Sort do for each pair of adjacent array elements
Sorting
pass 2
exchanges made do
for each pair of adjacent array elements
if the values in a pair are out of order
Exchange the values
while the array is not sorted 42 60 75 27 83
[0]
[1]
[2]
[3]
[4]

17. Trace of Bubble Sort do for each pair of adjacent array elements
Sorting
pass 2
exchanges made 1 do
for each pair of adjacent array elements
if the values in a pair are out of order
Exchange the values
while the array is not sorted 42 60 27 75 83
[0]
[1]
[2]
[3]
[4]

18. Trace of Bubble Sort do for each pair of adjacent array elements
Sorting
pass 2
exchanges made 1 do
for each pair of adjacent array elements
if the values in a pair are out of order
Exchange the values
while the array is not sorted 42 60 27 75 83
[0]
[1]
[2]
[3]
[4]

19. Trace of Bubble Sort do for each pair of adjacent array elements
Sorting
pass 3
exchanges made do
for each pair of adjacent array elements
if the values in a pair are out of order
Exchange the values
while the array is not sorted 42 60 27 75 83
[0]
[1]
[2]
[3]
[4]

20. Trace of Bubble Sort do for each pair of adjacent array elements
Sorting
pass 3
exchanges made do
for each pair of adjacent array elements
if the values in a pair are out of order
Exchange the values
while the array is not sorted 42 60 27 75 83
[0]
[1]
[2]
[3]
[4]

21. Trace of Bubble Sort do for each pair of adjacent array elements
Sorting
pass 3
exchanges made 1 do
for each pair of adjacent array elements
if the values in a pair are out of order
Exchange the values
while the array is not sorted 42 27 60 75 83
[0]
[1]
[2]
[3]
[4]

22. Trace of Bubble Sort do for each pair of adjacent array elements
Sorting
pass 3
exchanges made 1 do
for each pair of adjacent array elements
if the values in a pair are out of order
Exchange the values
while the array is not sorted 42 27 60 75 83
[0]
[1]
[2]
[3]
[4]

23. Trace of Bubble Sort do for each pair of adjacent array elements
Sorting
pass 4
exchanges made do
for each pair of adjacent array elements
if the values in a pair are out of order
Exchange the values
while the array is not sorted 42 27 60 75 83
[0]
[1]
[2]
[3]
[4]

24. Trace of Bubble Sort do for each pair of adjacent array elements
Sorting
pass 4
exchanges made 1 do
for each pair of adjacent array elements
if the values in a pair are out of order
Exchange the values
while the array is not sorted 27 42 60 75 83
[0]
[1]
[2]
[3]
[4]

25. Trace of Bubble Sort do for each pair of adjacent array elements
Sorting
pass 4
exchanges made 1 do
for each pair of adjacent array elements
if the values in a pair are out of order
Exchange the values
while the array is not sorted 27 42 60 75 83
[0]
[1]
[2]
[3]
[4]

26. Trace of Bubble Sort do for each pair of adjacent array elements
Sorting
pass 4
exchanges made 1 do
for each pair of adjacent array elements
if the values in a pair are out of order
Exchange the values
while the array is not sorted 27 42 60 75 83
[0]
[1]
[2]
[3]
[4]
Where n is the length of the array, after the completion of n – 1 passes (4, in this example) the array is sorted

27. Trace of Bubble Sort do for each pair of adjacent array elements
Sorting
pass 4
exchanges made 1 do
for each pair of adjacent array elements
if the values in a pair are out of order
Exchange the values
while the array is not sorted 27 42 60 75 83
[0]
[1]
[2]
[3]
[4]
Sometimes an array will be sorted before n – 1 passes. This can be detected if there are no exchanges made during a pass through the array

28. The algorithm can be modified to detect exchanges (next)
Trace of Bubble Sort
Sorting
pass 4
exchanges made 1 do
for each pair of adjacent array elements
if the values in a pair are out of order
Exchange the values
while the array is not sorted 27 42 60 75 83
[0]
[1]
[2]
[3]
[4]
The algorithm can be modified to detect exchanges (next)

29. Refined Bubble Sort Refinement of Bubble Sort Algorithm (Steps 2–4)
Sorting
Refinement of Bubble Sort Algorithm (Steps 2–4)
2.1 Initialize exchanges to false. // No exchanges yet—array may be sorted
2.2 for each pair of adjacent array elements
if the values in a pair are out of order
Exchange the values.
Set exchanges to true. // Made an exchange, array not sorted

30. Analysis of Bubble Sort
Sorting
The number of comparisons and exchanges is represented by
(n – 1) + (n – 2)
Worst case:
number of comparisons is O(n2).
number of exchanges is O(n2).
Compared to selection sort with its O(n2) comparisons and O(n) exchanges, bubble sort usually performs worse.
If the array is sorted early, the later comparisons and exchanges are not performed and performance is improved.
The best case occurs when the array is sorted already
one pass is required (O(n) comparisons).
no exchanges are required (O(1) exchanges).
Bubble sort works well on arrays nearly sorted and worst on inverted arrays (elements are in reverse sorted order).

31. Bubble Sort Implementation
Sorting
#ifndef BUBBLESORT_H_
#define BUBBLESORT_H_
#include <algorithm>
/** Sort data in the specified sequence using bubble sort.
@param first An iterator that references the first element in the sequence to be sorted
@param last An iterator that references 1 past the end of the sequence */
template<typename RI>
void bubble_sort(RI first, RI last) {
int pass = 1;
bool exchanges; do
{ // Invariant: Elements after position last - pass are in place.
exchanges = false; // No exchanges yet.
// Compare each pair of adjacent elements.
for (RI first_of_pair = first; first_of_pair != last - pass; ++first_of_pair)
RI second_of_pair = first_of_pair + 1;
if (*second_of_pair < *first_of_pair)
{ // Exchange pair.
std::iter_swap(first_of_pair, second_of_pair);
exchanges = true; // Set flag. }
pass++;
} while (exchanges);
return;
#endif

32. Sort the following integer array in ascending order using bubble sort
Sort the following integer array in ascending order using bubble sort. Show each step. 26 1 54 2 93 3 17 4 77 5 31 6 44 7 55 8 20
How many exchanges?

33. 10.4, pgs. 581-586 10.4 Insertion Sort Analysis of Insertion Sort
Code for Insertion Sort
Using iterator_traits to Determine the Data Type of an Element
10.4, pgs

34. Insertion Sort
Sorting
Another quadratic sort, insertion sort, is based on the technique used by card players to arrange a hand of cards.
The player keeps the cards that have been picked up so far in sorted order.
When the player picks up a new card, the player makes room for the new card and then inserts it in its proper place.
Algorithm:
Start with a sorted subarray, consisting of only the first element.
Insert the second element either in front of or behind the first element, producing a sorted subarray of size 2.
Insert the third element in front of, between, or behind the first two elements.
Continue until all elements have been inserted.

35. Insertion Sort
Sorting
for each array element from the second (next_pos = 1) to the last
Insert the element at next_pos where it belongs in the array, increasing the length of the sorted subarray by 1 element 30 25 15 20 28
[0]
[1]
[2]
[3]
[4]
To adapt the insertion algorithm to an array that is filled with data, we start with a sorted subarray consisting of only the first element

36. Insertion Sort
Sorting
next_pos 1
for each array element from the second (next_pos = 1) to the last
Insert the element at next_pos where it belongs in the array, increasing the length of the sorted subarray by 1 element 30 25 15 20 28
[0]
[1]
[2]
[3]
[4]
next_pos

37. Insertion Sort
Sorting
next_pos 1
for each array element from the second (next_pos = 1) to the last
Insert the element at next_pos where it belongs in the array, increasing the length of the sorted subarray by 1 element 25 30 15 20 28
[0]
[1]
[2]
[3]
[4]
next_pos

38. Insertion Sort
Sorting
next_pos 2
for each array element from the second (next_pos = 1) to the last
Insert the element at next_pos where it belongs in the array, increasing the length of the sorted subarray by 1 element 25 30 15 20 28
[0]
[1]
[2]
[3]
[4]
next_pos

39. Insertion Sort
Sorting
next_pos 2
for each array element from the second (next_pos = 1) to the last
Insert the element at next_pos where it belongs in the array, increasing the length of the sorted subarray by 1 element 15 25 30 20 28
[0]
[1]
[2]
[3]
[4]
next_pos

40. Insertion Sort
Sorting
next_pos 3
for each array element from the second (next_pos = 1) to the last
Insert the element at next_pos where it belongs in the array, increasing the length of the sorted subarray by 1 element 15 25 30 20 28
[0]
[1]
[2]
[3]
[4]
next_pos

41. Insertion Sort
Sorting
next_pos 3
for each array element from the second (next_pos = 1) to the last
Insert the element at next_pos where it belongs in the array, increasing the length of the sorted subarray by 1 element 15 20 25 30 28
[0]
[1]
[2]
[3]
[4]
next_pos

42. Insertion Sort
Sorting
next_pos 4
for each array element from the second (next_pos = 1) to the last
Insert the element at next_pos where it belongs in the array, increasing the length of the sorted subarray by 1 element 15 20 25 30 28
[0]
[1]
[2]
[3]
[4]
next_pos

43. Insertion Sort
Sorting
next_pos 4
for each array element from the second (next_pos = 1) to the last
Insert the element at next_pos where it belongs in the array, increasing the length of the sorted subarray by 1 element 15 20 25 28 30
[0]
[1]
[2]
[3]
[4]
next_pos

44. Insertion Sort
Sorting
next_pos -
for each array element from the second (next_pos = 1) to the last
Insert the element at next_pos where it belongs in the array, increasing the length of the sorted subarray by 1 element 15 20 25 28 30
[0]
[1]
[2]
[3]
[4]

45. Insertion Sort Refinement
Sorting
for each array element from the second (next_pos = 1) to the last
next_pos is the position of the element to insert
Save the value of the element to insert in next_val
while next_pos > 0 and the element at next_pos – 1 > next_val
Shift the element at next_pos – 1 to position next_pos
Decrement next_pos by 1
Insert next_val at next_pos 30 25 15 20 28
[0]
[1]
[2]
[3]
[4]

46. Insertion Sort Refinement
Sorting
next_pos 1
next_val
for each array element from the second (next_pos = 1) to the last
next_pos is the position of the element to insert
Save the value of the element to insert in next_val
while next_pos > 0 and the element at next_pos – 1 > next_val
Shift the element at next_pos – 1 to position next_pos
Decrement next_pos by 1
Insert next_val at next_pos 30 25 15 20 28
[0]
[1]
[2]
[3]
[4]
loop position

47. Insertion Sort Refinement
Sorting
next_pos 1
next_val
for each array element from the second (next_pos = 1) to the last
next_pos is the position of the element to insert
Save the value of the element to insert in next_val
while next_pos > 0 and the element at next_pos – 1 > next_val
Shift the element at next_pos – 1 to position next_pos
Decrement next_pos by 1
Insert next_val at next_pos 30 25 15 20 28
[0]
[1]
[2]
[3]
[4]
loop position
next_pos

48. Insertion Sort Refinement
Sorting
next_pos 1
next_val 25
for each array element from the second (next_pos = 1) to the last
next_pos is the position of the element to insert
Save the value of the element to insert in next_val
while next_pos > 0 and the element at next_pos – 1 > next_val
Shift the element at next_pos – 1 to position next_pos
Decrement next_pos by 1
Insert next_val at next_pos 30 25 15 20 28
[0]
[1]
[2]
[3]
[4]
loop position
next_pos

49. Insertion Sort Refinement
Sorting
next_pos 1
next_val 25
for each array element from the second (next_pos = 1) to the last
next_pos is the position of the element to insert
Save the value of the element to insert in next_val
while next_pos > 0 and the element at next_pos – 1 > next_val
Shift the element at next_pos – 1 to position next_pos
Decrement next_pos by 1
Insert next_val at next_pos 30 25 15 20 28
[0]
[1]
[2]
[3]
[4]
loop position
next_pos

50. Insertion Sort Refinement
Sorting
next_pos 1
next_val 25
for each array element from the second (next_pos = 1) to the last
next_pos is the position of the element to insert
Save the value of the element to insert in next_val
while next_pos > 0 and the element at next_pos – 1 > next_val
Shift the element at next_pos – 1 to position next_pos
Decrement next_pos by 1
Insert next_val at next_pos 30 15 20 28
[0]
[1]
[2]
[3]
[4]
loop position
next_pos

51. Insertion Sort Refinement
Sorting
next_pos
next_val 25
for each array element from the second (next_pos = 1) to the last
next_pos is the position of the element to insert
Save the value of the element to insert in next_val
while next_pos > 0 and the element at next_pos – 1 > next_val
Shift the element at next_pos – 1 to position next_pos
Decrement next_pos by 1
Insert next_val at next_pos 30 15 20 28
[0]
[1]
[2]
[3]
[4]
next_pos
loop position

52. Insertion Sort Refinement
Sorting
next_pos
next_val 25
for each array element from the second (next_pos = 1) to the last
next_pos is the position of the element to insert
Save the value of the element to insert in next_val
while next_pos > 0 and the element at next_pos – 1 > next_val
Shift the element at next_pos – 1 to position next_pos
Decrement next_pos by 1
Insert next_val at next_pos 30 15 20 28
[0]
[1]
[2]
[3]
[4]
next_pos
loop position

53. Insertion Sort Refinement
Sorting
next_pos
next_val 25
for each array element from the second (next_pos = 1) to the last
next_pos is the position of the element to insert
Save the value of the element to insert in next_val
while next_pos > 0 and the element at next_pos – 1 > next_val
Shift the element at next_pos – 1 to position next_pos
Decrement next_pos by 1
Insert next_val at next_pos 25 30 15 20 28
[0]
[1]
[2]
[3]
[4]
next_pos
loop position

54. Insertion Sort Refinement
Sorting
next_pos
next_val 25
for each array element from the second (next_pos = 1) to the last
next_pos is the position of the element to insert
Save the value of the element to insert in next_val
while next_pos > 0 and the element at next_pos – 1 > next_val
Shift the element at next_pos – 1 to position next_pos
Decrement next_pos by 1
Insert next_val at next_pos 25 30 15 20 28
[0]
[1]
[2]
[3]
[4]
loop position

55. Insertion Sort Refinement
Sorting
next_pos 2
next_val 25
for each array element from the second (next_pos = 1) to the last
next_pos is the position of the element to insert
Save the value of the element to insert in next_val
while next_pos > 0 and the element at next_pos – 1 > next_val
Shift the element at next_pos – 1 to position next_pos
Decrement next_pos by 1
Insert next_val at next_pos 25 30 15 20 28
[0]
[1]
[2]
[3]
[4]
loop position
next_pos

56. Insertion Sort Refinement
Sorting
next_pos 2
next_val 15
for each array element from the second (next_pos = 1) to the last
next_pos is the position of the element to insert
Save the value of the element to insert in next_val
while next_pos > 0 and the element at next_pos – 1 > next_val
Shift the element at next_pos – 1 to position next_pos
Decrement next_pos by 1
Insert next_val at next_pos 25 30 15 20 28
[0]
[1]
[2]
[3]
[4]
loop position
next_pos

57. Insertion Sort Refinement
Sorting
next_pos 2
next_val 15
for each array element from the second (next_pos = 1) to the last
next_pos is the position of the element to insert
Save the value of the element to insert in next_val
while next_pos > 0 and the element at next_pos – 1 > next_val
Shift the element at next_pos – 1 to position next_pos
Decrement next_pos by 1
Insert next_val at next_pos 25 30 15 20 28
[0]
[1]
[2]
[3]
[4]
loop position
next_pos

58. Insertion Sort Refinement
Sorting
next_pos 2
next_val 15
for each array element from the second (next_pos = 1) to the last
next_pos is the position of the element to insert
Save the value of the element to insert in next_val
while next_pos > 0 and the element at next_pos – 1 > next_val
Shift the element at next_pos – 1 to position next_pos
Decrement next_pos by 1
Insert next_val at next_pos 25 30 20 28
[0]
[1]
[2]
[3]
[4]
loop position
next_pos

59. Insertion Sort Refinement
Sorting
next_pos 1
next_val 15
for each array element from the second (next_pos = 1) to the last
next_pos is the position of the element to insert
Save the value of the element to insert in next_val
while next_pos > 0 and the element at next_pos – 1 > next_val
Shift the element at next_pos – 1 to position next_pos
Decrement next_pos by 1
Insert next_val at next_pos 25 30 20 28
[0]
[1]
[2]
[3]
[4]
next_pos
loop position

60. Insertion Sort Refinement
Sorting
next_pos 1
next_val 15
for each array element from the second (next_pos = 1) to the last
next_pos is the position of the element to insert
Save the value of the element to insert in next_val
while next_pos > 0 and the element at next_pos – 1 > next_val
Shift the element at next_pos – 1 to position next_pos
Decrement next_pos by 1
Insert next_val at next_pos 25 30 20 28
[0]
[1]
[2]
[3]
[4]
next_pos
loop position

61. Insertion Sort Refinement
Sorting
next_pos 1
next_val 15
for each array element from the second (next_pos = 1) to the last
next_pos is the position of the element to insert
Save the value of the element to insert in next_val
while next_pos > 0 and the element at next_pos – 1 > next_val
Shift the element at next_pos – 1 to position next_pos
Decrement next_pos by 1
Insert next_val at next_pos 25 30 20 28
[0]
[1]
[2]
[3]
[4]
next_pos
loop position

62. Insertion Sort Refinement
Sorting
next_pos
next_val 15
for each array element from the second (next_pos = 1) to the last
next_pos is the position of the element to insert
Save the value of the element to insert in next_val
while next_pos > 0 and the element at next_pos – 1 > next_val
Shift the element at next_pos – 1 to position next_pos
Decrement next_pos by 1
Insert next_val at next_pos 25 30 20 28
[0]
[1]
[2]
[3]
[4]
next_pos
loop position

63. Insertion Sort Refinement
Sorting
next_pos
next_val 15
for each array element from the second (next_pos = 1) to the last
next_pos is the position of the element to insert
Save the value of the element to insert in next_val
while next_pos > 0 and the element at next_pos – 1 > next_val
Shift the element at next_pos – 1 to position next_pos
Decrement next_pos by 1
Insert next_val at next_pos 25 30 20 28
[0]
[1]
[2]
[3]
[4]
next_pos
loop position

64. Insertion Sort Refinement
Sorting
next_pos
next_val 15
for each array element from the second (next_pos = 1) to the last
next_pos is the position of the element to insert
Save the value of the element to insert in next_val
while next_pos > 0 and the element at next_pos – 1 > next_val
Shift the element at next_pos – 1 to position next_pos
Decrement next_pos by 1
Insert next_val at next_pos 15 25 30 20 28
[0]
[1]
[2]
[3]
[4]
next_pos
loop position

65. Insertion Sort Refinement
Sorting
next_pos
next_val 15
for each array element from the second (next_pos = 1) to the last
next_pos is the position of the element to insert
Save the value of the element to insert in next_val
while next_pos > 0 and the element at next_pos – 1 > next_val
Shift the element at next_pos – 1 to position next_pos
Decrement next_pos by 1
Insert next_val at next_pos 15 25 30 20 28
[0]
[1]
[2]
[3]
[4]
next_pos
loop position

66. Insertion Sort Refinement
Sorting
next_pos 3
next_val 15
for each array element from the second (next_pos = 1) to the last
next_pos is the position of the element to insert
Save the value of the element to insert in next_val
while next_pos > 0 and the element at next_pos – 1 > next_val
Shift the element at next_pos – 1 to position next_pos
Decrement next_pos by 1
Insert next_val at next_pos 15 25 30 20 28
[0]
[1]
[2]
[3]
[4]
loop position
next_pos

67. Insertion Sort Refinement
Sorting
next_pos 3
next_val 20
for each array element from the second (next_pos = 1) to the last
next_pos is the position of the element to insert
Save the value of the element to insert in next_val
while next_pos > 0 and the element at next_pos – 1 > next_val
Shift the element at next_pos – 1 to position next_pos
Decrement next_pos by 1
Insert next_val at next_pos 15 25 30 20 28
[0]
[1]
[2]
[3]
[4]
loop position
next_pos

68. Insertion Sort Refinement
Sorting
next_pos 3
next_val 20
for each array element from the second (next_pos = 1) to the last
next_pos is the position of the element to insert
Save the value of the element to insert in next_val
while next_pos > 0 and the element at next_pos – 1 > next_val
Shift the element at next_pos – 1 to position next_pos
Decrement next_pos by 1
Insert next_val at next_pos 15 25 30 20 28
[0]
[1]
[2]
[3]
[4]
loop position
next_pos

69. Insertion Sort Refinement
Sorting
next_pos 3
next_val 20
for each array element from the second (next_pos = 1) to the last
next_pos is the position of the element to insert
Save the value of the element to insert in next_val
while next_pos > 0 and the element at next_pos – 1 > next_val
Shift the element at next_pos – 1 to position next_pos
Decrement next_pos by 1
Insert next_val at next_pos 15 25 30 28
[0]
[1]
[2]
[3]
[4]
loop position
next_pos

70. Insertion Sort Refinement
Sorting
next_pos 2
next_val 20
for each array element from the second (next_pos = 1) to the last
next_pos is the position of the element to insert
Save the value of the element to insert in next_val
while next_pos > 0 and the element at next_pos – 1 > next_val
Shift the element at next_pos – 1 to position next_pos
Decrement next_pos by 1
Insert next_val at next_pos 15 25 30 28
[0]
[1]
[2]
[3]
[4]
next_pos
loop position

71. Insertion Sort Refinement
Sorting
next_pos 2
next_val 20
for each array element from the second (next_pos = 1) to the last
next_pos is the position of the element to insert
Save the value of the element to insert in next_val
while next_pos > 0 and the element at next_pos – 1 > next_val
Shift the element at next_pos – 1 to position next_pos
Decrement next_pos by 1
Insert next_val at next_pos 15 25 30 28
[0]
[1]
[2]
[3]
[4]
next_pos
loop position

72. Insertion Sort Refinement
Sorting
next_pos 2
next_val 20
for each array element from the second (next_pos = 1) to the last
next_pos is the position of the element to insert
Save the value of the element to insert in next_val
while next_pos > 0 and the element at next_pos – 1 > next_val
Shift the element at next_pos – 1 to position next_pos
Decrement next_pos by 1
Insert next_val at next_pos 15 25 30 28
[0]
[1]
[2]
[3]
[4]
next_pos
loop position

73. Insertion Sort Refinement
Sorting
next_pos 1
next_val 20
for each array element from the second (next_pos = 1) to the last
next_pos is the position of the element to insert
Save the value of the element to insert in next_val
while next_pos > 0 and the element at next_pos – 1 > next_val
Shift the element at next_pos – 1 to position next_pos
Decrement next_pos by 1
Insert next_val at next_pos 15 25 30 28
[0]
[1]
[2]
[3]
[4]
next_pos
loop position

74. Insertion Sort Refinement
Sorting
next_pos 1
next_val 20
for each array element from the second (next_pos = 1) to the last
next_pos is the position of the element to insert
Save the value of the element to insert in next_val
while next_pos > 0 and the element at next_pos – 1 > next_val
Shift the element at next_pos – 1 to position next_pos
Decrement next_pos by 1
Insert next_val at next_pos 15 25 30 28
[0]
[1]
[2]
[3]
[4]
next_pos
loop position

75. Insertion Sort Refinement
Sorting
next_pos 1
next_val 20
for each array element from the second (next_pos = 1) to the last
next_pos is the position of the element to insert
Save the value of the element to insert in next_val
while next_pos > 0 and the element at next_pos – 1 > next_val
Shift the element at next_pos – 1 to position next_pos
Decrement next_pos by 1
Insert next_val at next_pos 15 20 25 30 28
[0]
[1]
[2]
[3]
[4]
next_pos
loop position

76. Insertion Sort Refinement
Sorting
next_pos 1
next_val 20
for each array element from the second (next_pos = 1) to the last
next_pos is the position of the element to insert
Save the value of the element to insert in next_val
while next_pos > 0 and the element at next_pos – 1 > next_val
Shift the element at next_pos – 1 to position next_pos
Decrement next_pos by 1
Insert next_val at next_pos 15 20 25 30 28
[0]
[1]
[2]
[3]
[4]
loop position

77. Insertion Sort Refinement
Sorting
next_pos 4
next_val 20
for each array element from the second (next_pos = 1) to the last
next_pos is the position of the element to insert
Save the value of the element to insert in next_val
while next_pos > 0 and the element at next_pos – 1 > next_val
Shift the element at next_pos – 1 to position next_pos
Decrement next_pos by 1
Insert next_val at next_pos 15 20 25 30 28
[0]
[1]
[2]
[3]
[4]
loop position
next_pos

78. Insertion Sort Refinement
Sorting
next_pos 4
next_val 28
for each array element from the second (next_pos = 1) to the last
next_pos is the position of the element to insert
Save the value of the element to insert in next_val
while next_pos > 0 and the element at next_pos – 1 > next_val
Shift the element at next_pos – 1 to position next_pos
Decrement next_pos by 1
Insert next_val at next_pos 15 20 25 30 28
[0]
[1]
[2]
[3]
[4]
loop position
next_pos

79. Insertion Sort Refinement
Sorting
next_pos 4
next_val 28
for each array element from the second (next_pos = 1) to the last
next_pos is the position of the element to insert
Save the value of the element to insert in next_val
while next_pos > 0 and the element at next_pos – 1 > next_val
Shift the element at next_pos – 1 to position next_pos
Decrement next_pos by 1
Insert next_val at next_pos 15 20 25 30 28
[0]
[1]
[2]
[3]
[4]
loop position
next_pos

80. Insertion Sort Refinement
Sorting
next_pos 4
next_val 28
for each array element from the second (next_pos = 1) to the last
next_pos is the position of the element to insert
Save the value of the element to insert in next_val
while next_pos > 0 and the element at next_pos – 1 > next_val
Shift the element at next_pos – 1 to position next_pos
Decrement next_pos by 1
Insert next_val at next_pos 15 20 25 30
[0]
[1]
[2]
[3]
[4]
loop position
next_pos

81. Insertion Sort Refinement
Sorting
next_pos 3
next_val 28
for each array element from the second (next_pos = 1) to the last
next_pos is the position of the element to insert
Save the value of the element to insert in next_val
while next_pos > 0 and the element at next_pos – 1 > next_val
Shift the element at next_pos – 1 to position next_pos
Decrement next_pos by 1
Insert next_val at next_pos 15 20 25 30
[0]
[1]
[2]
[3]
[4]
next_pos
loop position

82. Insertion Sort Refinement
Sorting
next_pos 3
next_val 28
for each array element from the second (next_pos = 1) to the last
next_pos is the position of the element to insert
Save the value of the element to insert in next_val
while next_pos > 0 and the element at next_pos – 1 > next_val
Shift the element at next_pos – 1 to position next_pos
Decrement next_pos by 1
Insert next_val at next_pos 15 20 25 30
[0]
[1]
[2]
[3]
[4]
next_pos
loop position

83. Insertion Sort Refinement
Sorting
next_pos 3
next_val 28
for each array element from the second (next_pos = 1) to the last
next_pos is the position of the element to insert
Save the value of the element to insert in next_val
while next_pos > 0 and the element at next_pos – 1 > next_val
Shift the element at next_pos – 1 to position next_pos
Decrement next_pos by 1
Insert next_val at next_pos 15 20 25 28 30
[0]
[1]
[2]
[3]
[4]
next_pos
loop position

84. Insertion Sort Refinement
Sorting
next_pos 3
next_val 28
for each array element from the second (next_pos = 1) to the last
next_pos is the position of the element to insert
Save the value of the element to insert in next_val
while next_pos > 0 and the element at next_pos – 1 > next_val
Shift the element at next_pos – 1 to position next_pos
Decrement next_pos by 1
Insert next_val at next_pos 15 20 25 28 30
[0]
[1]
[2]
[3]
[4]

85. Analysis of Insertion Sort
Sorting
The insertion step is performed n – 1 times.
In the worst case, all elements in the sorted subarray are compared to next_val for each insertion - the maximum number of comparisons then will be:
(n – 2) + (n – 1)
which is O(n2).
In the best case (when the array is sorted already), only one comparison is required for each insertion - the number of comparisons is O(n).
The number of shifts performed during an insertion is one less than the number of comparisons, or, when the new value is the smallest so far, it is the same as the number of comparisons.
A shift in an insertion sort requires movement of only 1 item, while an exchange in a bubble or selection sort involves a temporary item and the movement of three items.
A C++ array of objects contains the actual objects, and it is these actual objects that are changed.

86. Insertion Sort Sorting #ifndef INSERTIONSORT_H_
#define INSERTIONSORT_H_
#include <algorithm>
/** Sort data in the specified range using insertion sort.
@param first An iterator that references the first element in the sequence
@param last An iterator that references 1 past the end of the sequence */
template<typename RI>
void insertion_sort(RI first, RI last) {
for (RI next_pos = first + 1; next_pos != last; ++next_pos)
insert(first, next_pos); // Insert at position next_pos in subarray }
void insert(RI first, RI next_pos)
while ( (next_pos != first) && (*next_pos < *(next_pos - 1)) )
std::iter_swap(next_pos, next_pos - 1); // Exchange pair of values
--next_pos; // Check next smaller element
#endif // INSERTIONSORT_H

87. Sort the following integer array in ascending order using insertion sort. Show each step.26 1 54 2 93 3 17 4 77 5 31 6 44 7 55 8 20
How many exchanges?

88. 10.5, pgs. 586-588 10.5 Comparison of Quadratic Sorts
Comparisons versus Exchanges
10.5, pgs

89. Comparison of Quadratic Sorts
Sorting

90. Comparison of Quadratic Sorts
Sorting
Selection sort
gives the best performance for most arrays.
takes advantage of any partial sorting in the array and uses less costly shifts.
almost always outperforms bubble sort.
Insertion sort
usually performs about half as many comparisons as selection sort.
advantageous for some real-time applications that selection sort will perform identically regardless of the order of the array.
runs efficiently if the array is already sorted or "close to sorted."
Bubble sort
generally gives the worst performance, unless the array is nearly sorted.
The only significant advantage that bubble sort has over most other implementations, even quicksort, but not insertion sort, is that the ability to detect that the list is sorted is efficiently built into the algorithm.

91. Comparison of Quadratic Sorts
Sorting
Quadratic Sorts:
Big-O analysis ignores constants and overhead.
None of the quadratic sort algorithms are particularly good for large arrays (n > 100).
The best sorting algorithms provide n log n average case performance.
All quadratic sorts require storage for the array being sorted.
While there are also storage requirements for variables, for large n, the size of the array dominates and extra space usage is O(1).
However, the array is sorted in place.
Insertion sort or selection sort are both typically faster than divde- and-conquer algorithms for small arrays (i.e. fewer than elements).
A useful optimization in practice for the recursive algorithms is to switch to insertion sort or selection sort for "small enough" sublists.

92. Comparisons versus Exchanges
Sorting
In C++, an exchange requires a swap of two objects using a third object as an intermediary.
A comparison requires an evaluation of the < operator, or a call to a comparison function.
The cost of a comparison depends on its complexity, but is generally more costly than an exchange.
The cost of an exchange is proportional to the size of the objects being exchanged and, therefore, may be more costly than a comparison for large objects.