10.3 Bubble Sort Chapter 10 - Sorting

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.

Analysis of Bubble Sort Code for Bubble Sort 10.3, pgs. 577-580

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.

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]

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]

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]

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]

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]

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]

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

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]

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]

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]

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]

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]

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]

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]

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]

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]

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]

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]

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

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

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

Analysis of Bubble Sort Sorting The number of comparisons and exchanges is represented by (n – 1) + (n – 2) + ... + 3 + 2 + 1 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).

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

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?

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. 581-586

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.

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

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

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

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

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

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

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

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

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]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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: 1 + 2 + 3 + ... + (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.

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

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

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

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 10-20 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.

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.

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.