1. 10.3 Bubble Sort
Chapter 10 - Sorting

2. Initialization Lists Container Declaration Initialization
Sorting
Container Declaration
Initialization
pair<int, int> p
p = {3, 4};
vector<int> v
v = {1, 2, 5, 2};
set<int> s;
s = {4, 6, 2, 7, 4};
list<int> l;
l = {5, 6, 9, 1};
map<int, string> m;
m = {{1, "a"}, {2, {'b', 'c'}}};
template <typename T>
class Set {
private:
std::list<T> list_;
public:
Set(std::initializer_list<T> list) : list_(list) {} };
int main()
Set<string> mySet = { "Peaches", "Pears", "Apples", "Plums" };
return 0; }
Whenever a braced initializer list is encountered, the compiler converts it to an object of type std::initializer_list.

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

4. Bubble Sort Selection sort is relatively easy to understand.
Sorting
Selection sort is relatively easy to understand.
The array is sorted 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 (also known as sinking sort) is also a simple sorting algorithm
The array is sorted by repeatedly stepping through the array, comparing adjacent pairs, and swapping them if they are in the wrong order, until the array is sorted.
Smaller values bubble up to the top of the array and larger values sink to the bottom; hence the name.
Selection sort and Bubble sort are quadratic sorts.

5. Trace of Bubble Sort do for each adjacent pair
Sorting
pass 1
exchanges made do
for each adjacent pair
if item[i] > item[i+1]
exchange item[i],item[i+1]
endfor
while the array is not sorted 60 42 75 83 27
[0]
[1]
[2]
[3]
[4]

6. Trace of Bubble Sort do for each adjacent pair
Sorting
pass 1
exchanges made do
for each adjacent pair
if item[i] > item[i+1]
exchange item[i],item[i+1]
endfor
while the array is not sorted 42 60 75 83 27
[0]
[1]
[2]
[3]
[4]

7. Trace of Bubble Sort do for each adjacent pair
Sorting
pass 1
exchanges made do
for each adjacent pair
if item[i] > item[i+1]
exchange item[i],item[i+1]
endfor
while the array is not sorted 42 60 75 83 27
[0]
[1]
[2]
[3]
[4]

8. Trace of Bubble Sort do for each adjacent pair
Sorting
pass 1
exchanges made do
for each adjacent pair
if item[i] > item[i+1]
exchange item[i],item[i+1]
endfor
while the array is not sorted 42 60 75 83 27
[0]
[1]
[2]
[3]
[4]

9. Trace of Bubble Sort do for each adjacent pair
Sorting
pass 1
exchanges made do
for each adjacent pair
if item[i] > item[i+1]
exchange item[i],item[i+1]
endfor
while the array is not sorted 42 60 75 83 27
[0]
[1]
[2]
[3]
[4]

10. Trace of Bubble Sort do for each adjacent pair
Sorting
pass 1
exchanges made 2 do
for each adjacent pair
if item[i] > item[i+1]
exchange item[i],item[i+1]
endfor
while the array is not sorted 42 60 75 27 83
[0]
[1]
[2]
[3]
[4]

11. Trace of Bubble Sort do for each adjacent pair
Sorting
pass 1
exchanges made 2 do
for each adjacent pair
if item[i] > item[i+1]
exchange item[i],item[i+1]
endfor
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

12. Trace of Bubble Sort do for each adjacent pair
Sorting
pass 2
exchanges made do
for each adjacent pair
if item[i] > item[i+1]
exchange item[i],item[i+1]
endfor
while the array is not sorted 42 60 75 27 83
[0]
[1]
[2]
[3]
[4]

13. Trace of Bubble Sort do for each adjacent pair
Sorting
pass 2
exchanges made do
for each adjacent pair
if item[i] > item[i+1]
exchange item[i],item[i+1]
endfor
while the array is not sorted 42 60 75 27 83
[0]
[1]
[2]
[3]
[4]

14. Trace of Bubble Sort do for each adjacent pair
Sorting
pass 2
exchanges made do
for each adjacent pair
if item[i] > item[i+1]
exchange item[i],item[i+1]
endfor
while the array is not sorted 42 60 75 27 83
[0]
[1]
[2]
[3]
[4]

15. Trace of Bubble Sort do for each adjacent pair
Sorting
pass 2
exchanges made 1 do
for each adjacent pair
if item[i] > item[i+1]
exchange item[i],item[i+1]
endfor
while the array is not sorted 42 60 27 75 83
[0]
[1]
[2]
[3]
[4]

16. Trace of Bubble Sort do for each adjacent pair
Sorting
pass 2
exchanges made 1 do
for each adjacent pair
if item[i] > item[i+1]
exchange item[i],item[i+1]
endfor
while the array is not sorted 42 60 27 75 83
[0]
[1]
[2]
[3]
[4]

17. Trace of Bubble Sort do for each adjacent pair
Sorting
pass 3
exchanges made do
for each adjacent pair
if item[i] > item[i+1]
exchange item[i],item[i+1]
endfor
while the array is not sorted 42 60 27 75 83
[0]
[1]
[2]
[3]
[4]

18. Trace of Bubble Sort do for each adjacent pair
Sorting
pass 3
exchanges made do
for each adjacent pair
if item[i] > item[i+1]
exchange item[i],item[i+1]
endfor
while the array is not sorted 42 60 27 75 83
[0]
[1]
[2]
[3]
[4]

19. Trace of Bubble Sort do for each adjacent pair
Sorting
pass 3
exchanges made 1 do
for each adjacent pair
if item[i] > item[i+1]
exchange item[i],item[i+1]
endfor
while the array is not sorted 42 27 60 75 83
[0]
[1]
[2]
[3]
[4]

20. Trace of Bubble Sort do for each adjacent pair
Sorting
pass 3
exchanges made 1 do
for each adjacent pair
if item[i] > item[i+1]
exchange item[i],item[i+1]
endfor
while the array is not sorted 42 27 60 75 83
[0]
[1]
[2]
[3]
[4]

21. Trace of Bubble Sort do for each adjacent pair
Sorting
pass 4
exchanges made do
for each adjacent pair
if item[i] > item[i+1]
exchange item[i],item[i+1]
endfor
while the array is not sorted 42 27 60 75 83
[0]
[1]
[2]
[3]
[4]

22. Trace of Bubble Sort do for each adjacent pair
Sorting
pass 4
exchanges made 1 do
for each adjacent pair
if item[i] > item[i+1]
exchange item[i],item[i+1]
endfor
while the array is not sorted 27 42 60 75 83
[0]
[1]
[2]
[3]
[4]

23. Trace of Bubble Sort do for each adjacent pair
Sorting
pass 4
exchanges made 1 do
for each adjacent pair
if item[i] > item[i+1]
exchange item[i],item[i+1]
endfor
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

24. Trace of Bubble Sort do for each adjacent pair
Sorting
pass 4
exchanges made 1 do
for each adjacent pair
if item[i] > item[i+1]
exchange item[i],item[i+1]
endfor
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

25. The algorithm can be modified to detect exchanges
Refined Bubble Sort
Sorting
pass 1
exchanges made do
for each adjacent pair
if item[i] > item[i+1]
exchange item[i],item[i+1]
endfor
while the array is not sorted do
exchanges = false
for each adjacent pair
if item[i] > item[i+1]
exchange item[i],item[i+1]
exchanges = true
endfor
while exchanges == true 27 42 60 75 83
[0]
[1]
[2]
[3]
[4]
The algorithm can be modified to detect exchanges

26. 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).

27. 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

28. 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?

29. 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

30. 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 have been inserted.

31. Insertion Sort for next_pos = 1 to n - 1 for i = next_pos downto 1
Sorting
next_pos 1
for next_pos = 1 to n - 1
for i = next_pos downto 1
if item[i] > item[i - 1]
break
exchange item[i],item[i - 1]
endfor 30 25 15 20 28
[0]
[1]
[2]
[3]
[4]
next_pos
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

32. Insertion Sort for next_pos = 1 to n - 1 for i = next_pos downto 1
Sorting
next_pos 1
for next_pos = 1 to n - 1
for i = next_pos downto 1
if item[i] > item[i - 1]
break
exchange item[i],item[i - 1]
endfor 25 30 15 20 28
[0]
[1]
[2]
[3]
[4]
next_pos

33. Insertion Sort for next_pos = 1 to n - 1 for i = next_pos downto 1
Sorting
next_pos 2
for next_pos = 1 to n - 1
for i = next_pos downto 1
if item[i] > item[i - 1]
break
exchange item[i],item[i - 1]
endfor 25 30 15 20 28
[0]
[1]
[2]
[3]
[4]
next_pos

34. Insertion Sort for next_pos = 1 to n - 1 for i = next_pos downto 1
Sorting
next_pos 2
for next_pos = 1 to n - 1
for i = next_pos downto 1
if item[i] > item[i - 1]
break
exchange item[i],item[i - 1]
endfor 15 25 30 20 28
[0]
[1]
[2]
[3]
[4]
next_pos

35. Insertion Sort for next_pos = 1 to n - 1 for i = next_pos downto 1
Sorting
next_pos 3
for next_pos = 1 to n - 1
for i = next_pos downto 1
if item[i] > item[i - 1]
break
exchange item[i],item[i - 1]
endfor 15 25 30 20 28
[0]
[1]
[2]
[3]
[4]
next_pos

36. Insertion Sort for next_pos = 1 to n - 1 for i = next_pos downto 1
Sorting
next_pos 3
for next_pos = 1 to n - 1
for i = next_pos downto 1
if item[i] > item[i - 1]
break
exchange item[i],item[i - 1]
endfor 15 20 25 30 28
[0]
[1]
[2]
[3]
[4]
next_pos

37. Insertion Sort for next_pos = 1 to n - 1 for i = next_pos downto 1
Sorting
next_pos 4
for next_pos = 1 to n - 1
for i = next_pos downto 1
if item[i] > item[i - 1]
break
exchange item[i],item[i - 1]
endfor 15 20 25 30 28
[0]
[1]
[2]
[3]
[4]
next_pos

38. Insertion Sort for next_pos = 1 to n - 1 for i = next_pos downto 1
Sorting
next_pos 4
for next_pos = 1 to n - 1
for i = next_pos downto 1
if item[i] > item[i - 1]
break
exchange item[i],item[i - 1]
endfor 15 20 25 28 30
[0]
[1]
[2]
[3]
[4]
next_pos

39. Insertion Sort for next_pos = 1 to n - 1 for i = next_pos downto 1
Sorting
next_pos 4
for next_pos = 1 to n - 1
for i = next_pos downto 1
if item[i] > item[i - 1]
break
exchange item[i],item[i - 1]
endfor 15 20 25 28 30
[0]
[1]
[2]
[3]
[4]

40. Sort the following integer array in descending order using insertion sort. Show each step.26 1 54 2 93 3 17 4 77 5 31 6 44 7 55 8 20

41. Refined Insertion Sort
Sorting
Exchanges are expensive. By "rolling" items down and only do stores, the sort executes faster!
loop 1
next_pos
next_val
for loop = 1 to n - 1
next_pos = loop
next_val = item[next_pos]
while next_pos > 0 and
next_val < item[next_pos - 1]
item[next_pos] = item[next_pos - 1]
next_pos = next_pos – 1
endwhile
item[next_pos] = next_val
endfor 30 25 15 20 28
[0]
[1]
[2]
[3]
[4]
loop

42. Refined Insertion Sort
Sorting
loop 1
next_pos
next_val
for loop = 1 to n - 1
next_pos = loop
next_val = item[next_pos]
while next_pos > 0 and
next_val < item[next_pos - 1]
item[next_pos] = item[next_pos - 1]
next_pos = next_pos – 1
endwhile
item[next_pos] = next_val
endfor 30 25 15 20 28
[0]
[1]
[2]
[3]
[4]
loop
next_pos

43. Refined Insertion Sort
Sorting
loop 1
next_pos
next_val 25
for loop = 1 to n - 1
next_pos = loop
next_val = item[next_pos]
while next_pos > 0 and
next_val < item[next_pos - 1]
item[next_pos] = item[next_pos - 1]
next_pos = next_pos – 1
endwhile
item[next_pos] = next_val
endfor 30 25 15 20 28
[0]
[1]
[2]
[3]
[4]
loop
next_pos

44. Refined Insertion Sort
Sorting
loop 1
next_pos
next_val 25
for loop = 1 to n - 1
next_pos = loop
next_val = item[next_pos]
while next_pos > 0 and
next_val < item[next_pos - 1]
item[next_pos] = item[next_pos - 1]
next_pos = next_pos – 1
endwhile
item[next_pos] = next_val
endfor 30 25 15 20 28
[0]
[1]
[2]
[3]
[4]
loop
next_pos

45. Refined Insertion Sort
Sorting
loop 1
next_pos
next_val 25
for loop = 1 to n - 1
next_pos = loop
next_val = item[next_pos]
while next_pos > 0 and
next_val < item[next_pos - 1]
item[next_pos] = item[next_pos - 1]
next_pos = next_pos – 1
endwhile
item[next_pos] = next_val
endfor 30 15 20 28
[0]
[1]
[2]
[3]
[4]
loop
next_pos

46. Refined Insertion Sort
Sorting
loop 1
next_pos
next_val 25
for loop = 1 to n - 1
next_pos = loop
next_val = item[next_pos]
while next_pos > 0 and
next_val < item[next_pos - 1]
item[next_pos] = item[next_pos - 1]
next_pos = next_pos – 1
endwhile
item[next_pos] = next_val
endfor 30 15 20 28
[0]
[1]
[2]
[3]
[4]
next_pos
loop

47. Refined Insertion Sort
Sorting
loop 1
next_pos
next_val 25
for loop = 1 to n - 1
next_pos = loop
next_val = item[next_pos]
while next_pos > 0 and
next_val < item[next_pos - 1]
item[next_pos] = item[next_pos - 1]
next_pos = next_pos – 1
endwhile
item[next_pos] = next_val
endfor 30 15 20 28
[0]
[1]
[2]
[3]
[4]
next_pos
loop

48. Refined Insertion Sort
Sorting
loop 1
next_pos
next_val 25
for loop = 1 to n - 1
next_pos = loop
next_val = item[next_pos]
while next_pos > 0 and
next_val < item[next_pos - 1]
item[next_pos] = item[next_pos - 1]
next_pos = next_pos – 1
endwhile
item[next_pos] = next_val
endfor 25 30 15 20 28
[0]
[1]
[2]
[3]
[4]
next_pos
loop

49. Refined Insertion Sort
Sorting
loop 2
next_pos
next_val 25
for loop = 1 to n - 1
next_pos = loop
next_val = item[next_pos]
while next_pos > 0 and
next_val < item[next_pos - 1]
item[next_pos] = item[next_pos - 1]
next_pos = next_pos – 1
endwhile
item[next_pos] = next_val
endfor 25 30 15 20 28
[0]
[1]
[2]
[3]
[4]
next_pos
loop

50. Refined Insertion Sort
Sorting
loop 2
next_pos
next_val 25
for loop = 1 to n - 1
next_pos = loop
next_val = item[next_pos]
while next_pos > 0 and
next_val < item[next_pos - 1]
item[next_pos] = item[next_pos - 1]
next_pos = next_pos – 1
endwhile
item[next_pos] = next_val
endfor 25 30 15 20 28
[0]
[1]
[2]
[3]
[4]
loop
next_pos

51. Refined Insertion Sort
Sorting
loop 2
next_pos
next_val 15
for loop = 1 to n - 1
next_pos = loop
next_val = item[next_pos]
while next_pos > 0 and
next_val < item[next_pos - 1]
item[next_pos] = item[next_pos - 1]
next_pos = next_pos – 1
endwhile
item[next_pos] = next_val
endfor 25 30 15 20 28
[0]
[1]
[2]
[3]
[4]
loop
next_pos

52. Refined Insertion Sort
Sorting
loop 2
next_pos
next_val 15
for loop = 1 to n - 1
next_pos = loop
next_val = item[next_pos]
while next_pos > 0 and
next_val < item[next_pos - 1]
item[next_pos] = item[next_pos - 1]
next_pos = next_pos – 1
endwhile
item[next_pos] = next_val
endfor 25 30 15 20 28
[0]
[1]
[2]
[3]
[4]
loop
next_pos

53. Refined Insertion Sort
Sorting
loop 2
next_pos
next_val 15
for loop = 1 to n - 1
next_pos = loop
next_val = item[next_pos]
while next_pos > 0 and
next_val < item[next_pos - 1]
item[next_pos] = item[next_pos - 1]
next_pos = next_pos – 1
endwhile
item[next_pos] = next_val
endfor 25 30 20 28
[0]
[1]
[2]
[3]
[4]
loop
next_pos

54. Refined Insertion Sort
Sorting
loop 2
next_pos
next_val 15
for loop = 1 to n - 1
next_pos = loop
next_val = item[next_pos]
while next_pos > 0 and
next_val < item[next_pos - 1]
item[next_pos] = item[next_pos - 1]
next_pos = next_pos – 1
endwhile
item[next_pos] = next_val
endfor 25 30 20 28
[0]
[1]
[2]
[3]
[4]
next_pos
loop

55. Refined Insertion Sort
Sorting
loop 2
next_pos
next_val 15
for loop = 1 to n - 1
next_pos = loop
next_val = item[next_pos]
while next_pos > 0 and
next_val < item[next_pos - 1]
item[next_pos] = item[next_pos - 1]
next_pos = next_pos – 1
endwhile
item[next_pos] = next_val
endfor 25 30 20 28
[0]
[1]
[2]
[3]
[4]
next_pos
loop

56. Refined Insertion Sort
Sorting
loop 2
next_pos
next_val 15
for loop = 1 to n - 1
next_pos = loop
next_val = item[next_pos]
while next_pos > 0 and
next_val < item[next_pos - 1]
item[next_pos] = item[next_pos - 1]
next_pos = next_pos – 1
endwhile
item[next_pos] = next_val
endfor 25 30 20 28
[0]
[1]
[2]
[3]
[4]
next_pos
loop

57. Refined Insertion Sort
Sorting
loop 2
next_pos 1
next_val 15
for loop = 1 to n - 1
next_pos = loop
next_val = item[next_pos]
while next_pos > 0 and
next_val < item[next_pos - 1]
item[next_pos] = item[next_pos - 1]
next_pos = next_pos – 1
endwhile
item[next_pos] = next_val
endfor 25 30 20 28
[0]
[1]
[2]
[3]
[4]
next_pos
loop

58. Refined Insertion Sort
Sorting
loop 2
next_pos 1
next_val 15
for loop = 1 to n - 1
next_pos = loop
next_val = item[next_pos]
while next_pos > 0 and
next_val < item[next_pos - 1]
item[next_pos] = item[next_pos - 1]
next_pos = next_pos – 1
endwhile
item[next_pos] = next_val
endfor 25 30 20 28
[0]
[1]
[2]
[3]
[4]
next_pos
loop

59. Refined Insertion Sort
Sorting
loop 2
next_pos 1
next_val 15
for loop = 1 to n - 1
next_pos = loop
next_val = item[next_pos]
while next_pos > 0 and
next_val < item[next_pos - 1]
item[next_pos] = item[next_pos - 1]
next_pos = next_pos – 1
endwhile
item[next_pos] = next_val
endfor 15 25 30 20 28
[0]
[1]
[2]
[3]
[4]
next_pos
loop

60. Refined Insertion Sort
Sorting
loop 3
next_pos 1
next_val 15
for loop = 1 to n - 1
next_pos = loop
next_val = item[next_pos]
while next_pos > 0 and
next_val < item[next_pos - 1]
item[next_pos] = item[next_pos - 1]
next_pos = next_pos – 1
endwhile
item[next_pos] = next_val
endfor 15 25 30 20 28
[0]
[1]
[2]
[3]
[4]
next_pos
loop

61. Refined Insertion Sort
Sorting
loop 3
next_pos
next_val 15
for loop = 1 to n - 1
next_pos = loop
next_val = item[next_pos]
while next_pos > 0 and
next_val < item[next_pos - 1]
item[next_pos] = item[next_pos - 1]
next_pos = next_pos – 1
endwhile
item[next_pos] = next_val
endfor 15 25 30 20 28
[0]
[1]
[2]
[3]
[4]
loop
next_pos

62. Refined Insertion Sort
Sorting
loop 3
next_pos
next_val 20
for loop = 1 to n - 1
next_pos = loop
next_val = item[next_pos]
while next_pos > 0 and
next_val < item[next_pos - 1]
item[next_pos] = item[next_pos - 1]
next_pos = next_pos – 1
endwhile
item[next_pos] = next_val
endfor 15 25 30 20 28
[0]
[1]
[2]
[3]
[4]
loop
next_pos

63. Refined Insertion Sort
Sorting
loop 3
next_pos
next_val 20
for loop = 1 to n - 1
next_pos = loop
next_val = item[next_pos]
while next_pos > 0 and
next_val < item[next_pos - 1]
item[next_pos] = item[next_pos - 1]
next_pos = next_pos – 1
endwhile
item[next_pos] = next_val
endfor 15 25 30 28
[0]
[1]
[2]
[3]
[4]
loop
next_pos

64. Refined Insertion Sort
Sorting
loop 3
next_pos 2
next_val 20
for loop = 1 to n - 1
next_pos = loop
next_val = item[next_pos]
while next_pos > 0 and
next_val < item[next_pos - 1]
item[next_pos] = item[next_pos - 1]
next_pos = next_pos – 1
endwhile
item[next_pos] = next_val
endfor 15 25 30 28
[0]
[1]
[2]
[3]
[4]
next_pos
loop

65. Refined Insertion Sort
Sorting
loop 3
next_pos 2
next_val 20
for loop = 1 to n - 1
next_pos = loop
next_val = item[next_pos]
while next_pos > 0 and
next_val < item[next_pos - 1]
item[next_pos] = item[next_pos - 1]
next_pos = next_pos – 1
endwhile
item[next_pos] = next_val
endfor 15 25 30 28
[0]
[1]
[2]
[3]
[4]
next_pos
loop

66. Refined Insertion Sort
Sorting
loop 3
next_pos 2
next_val 20
for loop = 1 to n - 1
next_pos = loop
next_val = item[next_pos]
while next_pos > 0 and
next_val < item[next_pos - 1]
item[next_pos] = item[next_pos - 1]
next_pos = next_pos – 1
endwhile
item[next_pos] = next_val
endfor 15 25 30 28
[0]
[1]
[2]
[3]
[4]
next_pos
loop

67. Refined Insertion Sort
Sorting
loop 3
next_pos 2
next_val 20
for loop = 1 to n - 1
next_pos = loop
next_val = item[next_pos]
while next_pos > 0 and
next_val < item[next_pos - 1]
item[next_pos] = item[next_pos - 1]
next_pos = next_pos – 1
endwhile
item[next_pos] = next_val
endfor 15 25 30 28
[0]
[1]
[2]
[3]
[4]
next_pos
loop

68. Refined Insertion Sort
Sorting
loop 3
next_pos 1
next_val 20
for loop = 1 to n - 1
next_pos = loop
next_val = item[next_pos]
while next_pos > 0 and
next_val < item[next_pos - 1]
item[next_pos] = item[next_pos - 1]
next_pos = next_pos – 1
endwhile
item[next_pos] = next_val
endfor 15 25 30 28
[0]
[1]
[2]
[3]
[4]
next_pos
loop

69. Refined Insertion Sort
Sorting
loop 3
next_pos 1
next_val 20
for loop = 1 to n - 1
next_pos = loop
next_val = item[next_pos]
while next_pos > 0 and
next_val < item[next_pos - 1]
item[next_pos] = item[next_pos - 1]
next_pos = next_pos – 1
endwhile
item[next_pos] = next_val
endfor 15 25 30 28
[0]
[1]
[2]
[3]
[4]
next_pos
loop

70. Refined Insertion Sort
Sorting
loop 3
next_pos 1
next_val 20
for loop = 1 to n - 1
next_pos = loop
next_val = item[next_pos]
while next_pos > 0 and
next_val < item[next_pos - 1]
item[next_pos] = item[next_pos - 1]
next_pos = next_pos – 1
endwhile
item[next_pos] = next_val
endfor 15 25 30 28
[0]
[1]
[2]
[3]
[4]
next_pos
loop

71. Refined Insertion Sort
Sorting
loop 3
next_pos 1
next_val 20
for loop = 1 to n - 1
next_pos = loop
next_val = item[next_pos]
while next_pos > 0 and
next_val < item[next_pos - 1]
item[next_pos] = item[next_pos - 1]
next_pos = next_pos – 1
endwhile
item[next_pos] = next_val
endfor 15 20 25 30 28
[0]
[1]
[2]
[3]
[4]
next_pos
loop

72. Refined Insertion Sort
Sorting
loop 4
next_pos 1
next_val 20
for loop = 1 to n - 1
next_pos = loop
next_val = item[next_pos]
while next_pos > 0 and
next_val < item[next_pos - 1]
item[next_pos] = item[next_pos - 1]
next_pos = next_pos – 1
endwhile
item[next_pos] = next_val
endfor 15 20 25 30 28
[0]
[1]
[2]
[3]
[4]
next_pos
loop

73. Refined Insertion Sort
Sorting
loop 4
next_pos
next_val 20
for loop = 1 to n - 1
next_pos = loop
next_val = item[next_pos]
while next_pos > 0 and
next_val < item[next_pos - 1]
item[next_pos] = item[next_pos - 1]
next_pos = next_pos – 1
endwhile
item[next_pos] = next_val
endfor 15 20 25 30 28
[0]
[1]
[2]
[3]
[4]
loop
next_pos

74. Refined Insertion Sort
Sorting
loop 4
next_pos
next_val 28
for loop = 1 to n - 1
next_pos = loop
next_val = item[next_pos]
while next_pos > 0 and
next_val < item[next_pos - 1]
item[next_pos] = item[next_pos - 1]
next_pos = next_pos – 1
endwhile
item[next_pos] = next_val
endfor 15 20 25 30 28
[0]
[1]
[2]
[3]
[4]
loop
next_pos

75. Refined Insertion Sort
Sorting
loop 4
next_pos
next_val 28
for loop = 1 to n - 1
next_pos = loop
next_val = item[next_pos]
while next_pos > 0 and
next_val < item[next_pos - 1]
item[next_pos] = item[next_pos - 1]
next_pos = next_pos – 1
endwhile
item[next_pos] = next_val
endfor 15 20 25 30 28
[0]
[1]
[2]
[3]
[4]
loop
next_pos

76. Refined Insertion Sort
Sorting
loop 4
next_pos
next_val 28
for loop = 1 to n - 1
next_pos = loop
next_val = item[next_pos]
while next_pos > 0 and
next_val < item[next_pos - 1]
item[next_pos] = item[next_pos - 1]
next_pos = next_pos – 1
endwhile
item[next_pos] = next_val
endfor 15 20 25 30
[0]
[1]
[2]
[3]
[4]
loop
next_pos

77. Refined Insertion Sort
Sorting
loop 4
next_pos 3
next_val 28
for loop = 1 to n - 1
next_pos = loop
next_val = item[next_pos]
while next_pos > 0 and
next_val < item[next_pos - 1]
item[next_pos] = item[next_pos - 1]
next_pos = next_pos – 1
endwhile
item[next_pos] = next_val
endfor 15 20 25 30
[0]
[1]
[2]
[3]
[4]
next_pos
loop

78. Refined Insertion Sort
Sorting
loop 4
next_pos 3
next_val 28
for loop = 1 to n - 1
next_pos = loop
next_val = item[next_pos]
while next_pos > 0 and
next_val < item[next_pos - 1]
item[next_pos] = item[next_pos - 1]
next_pos = next_pos – 1
endwhile
item[next_pos] = next_val
endfor 15 20 25 30
[0]
[1]
[2]
[3]
[4]
next_pos
loop

79. Refined Insertion Sort
Sorting
loop 4
next_pos 3
next_val 28
for loop = 1 to n - 1
next_pos = loop
next_val = item[next_pos]
while next_pos > 0 and
next_val < item[next_pos - 1]
item[next_pos] = item[next_pos - 1]
next_pos = next_pos – 1
endwhile
item[next_pos] = next_val
endfor 15 20 25 30
[0]
[1]
[2]
[3]
[4]
next_pos
loop

80. Refined Insertion Sort
Sorting
loop 4
next_pos 3
next_val 28
for loop = 1 to n - 1
next_pos = loop
next_val = item[next_pos]
while next_pos > 0 and
next_val < item[next_pos - 1]
item[next_pos] = item[next_pos - 1]
next_pos = next_pos – 1
endwhile
item[next_pos] = next_val
endfor 15 20 25 28 30
[0]
[1]
[2]
[3]
[4]
next_pos
loop

81. Refined Insertion Sort
Sorting
loop 4
next_pos 3
next_val 28
for loop = 1 to n - 1
next_pos = loop
next_val = item[next_pos]
while next_pos > 0 and
next_val < item[next_pos - 1]
item[next_pos] = item[next_pos - 1]
next_pos = next_pos – 1
endwhile
item[next_pos] = next_val
endfor 15 20 25 28 30
[0]
[1]
[2]
[3]
[4]
next_pos
loop

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

83. 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.

84. 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

85. 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 at position next_pos in subarray
while ( (next_pos != first) && (*next_pos < *(next_pos - 1)) )
// Exchange pair of values
std::iter_swap(next_pos, next_pos - 1);
// Check next smaller element
--next_pos; }
#endif // INSERTIONSORT_H

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

87. Comparison of Quadratic Sorts
Sorting
Quadratic Sorts:
The best sorting algorithms provide n log n average case performance.
None of the quadratic sort algorithms are particularly good for large arrays (n > 100).
For small arrays (i.e. fewer than elements,) insertion sort and selection sort are both typically faster than divide-and-conquer algorithms.
A useful optimization in practice for the recursive algorithms is to switch to insertion sort or selection sort for "small enough" sub lists.
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).
The array is sorted in place.

88. Comparison of Quadratic Sorts
Sorting
Selection Sort
Bubble Sort
Insertion Sort
Exchanges:
In C++, an exchange requires a swap of two objects using a third object as an intermediary.
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.
Comparisons:
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.

89. Comparison of Quadratic Sorts
Sorting
Insertion sort
Simple, efficient for small data sets
Stable and sorts a list as elements are inserted.
Requires half as many comparisons as selection sort.
Runs efficiently if the array is already sorted or "close to sorted."
Selection sort
Simple, works well with structures that add and remove efficiently (linked lists.)
Takes advantage of any partial sorting in the array and uses less costly shifts.
Almost always outperforms bubble sort but worse than similar insertion sorts.
Bubble sort
Generally gives the worst performance, unless the array is nearly sorted.
Only significant advantage over most other implementations is the ability to detect that the list is sorted.