12.1.1. Introduction to Insertion Sort

So, let us continue with a discussion of sorting, and look at another simple sorting algorithm. There are many more motivations for sorting; starting from searching, to removing duplicates, to computing some statistical properties, such as frequency tables, and so on.

This chunk explains the basic concept of sorting and its purposes. Sorting is crucial for managing and organizing data efficiently. The motivations for sorting include simplifying searching tasks, eliminating duplicate entries from a dataset, and enabling the computation of various statistical measures, like frequency tables. Essentially, sorting makes it easier to analyze data and derive meaningful insights.

Imagine you have a pile of books that you've borrowed from the library. If they're all mixed up, it can take a long time to find a specific book whenever you need it. If you arrange them by title or author, you'll know exactly where to go, making your search much quicker and more efficient. This is similar to what sorting does for data.

So, the second strategy to sort this bunch of exam papers would be the following. You take the top most paper in the stack that you have, and create a new stack. Now you take the second paper and compare it to the first paper. If the mark is bigger, you put it above, because you wanted it in descending order. If the mark is smaller, you put it below. So, after this step, you have two stacks of papers in descending order.

This chunk introduces the basic mechanism of insertion sort using the analogy of sorting exam papers. The process starts with an empty stack, and one by one, exam papers are compared and placed into the correct position within the already sorted stack based on their marks. This iterative process continues until all papers are sorted, creating a final stack that is fully sorted in descending order.

Think about sorting playing cards in your hands. You start with the first card, and as you draw each subsequent card, you compare it with the ones you've already placed in order. If a new card is larger, you place it on top. If it's smaller, you find the right spot within your ordered cards. This is precisely how insertion sort works.

So, we start by building a sorted sequence with one element. This is called insertion sort. We insert each unsorted element into the correct place in the already sorted sequence. Each element is inserted into its correct place, leading to the name 'insertion sort.'

Here, we get a more specific look at the insertion sort algorithm. The method begins with a single element considered sorted. As more elements are introduced, each one is compared to the sorted portion to determine where it fits in. This step-by-step insertion ensures that with each new element added, the stack remains sorted. Therefore, after processing all elements, the entire array will be sorted.

Picture yourself baking a cake. You start with one layer, which is stable and solid. As you add additional layers, you ensure they fit perfectly atop the already arranged layers, creating a nice and tidy stack. This careful placement is similar to how insertion sort arranges elements into a perfectly sorted list.

This is a very straightforward iterative implementation. So, we can see now how this works on an array given to us. We first of all start with looking at this segment. Each time we try to insert a new element into the already sorted portion, we potentially look at multiple elements, which results in a time complexity of O(n^2) in the worst case.

In this chunk, the focus is on the performance aspect of insertion sort. It details how the algorithm works on a complete array and how the number of comparisons grows as the unsorted segment decreases in size with each insertion. The average and worst-case time complexity for insertion sort is O(n^2), primarily because each element may need to be compared against several others before finding its appropriate position in the sorted segment.

Consider how a small restaurant handles new orders during peak hours. If only a few new orders come in (like a smaller dataset), the staff can quickly process them with minimal errors. However, if a large wave of new orders arrives at once, it can take much longer to sort and deliver each dish due to the increasing number of comparisons and adjustments required.

So, once again as we saw for selection sort. There is a natural way to think of insertion sort as a recursive thing. We sort part of the array, and then we insert an element into that to grow it.

This chunk introduces the recursive nature of insertion sort. It illustrates how each segment of the array can be handled recursively, much like building up a sorted array piece by piece. By treating the process of inserting as a recursive call, it emphasizes how the algorithm can be structured to first sort a portion and then insert the next unsorted element, repeating this until the entire array is sorted.

Imagine a story being written, where each chapter builds upon the last. You write one chapter, then come back and add the next chapter by incorporating characters and storylines from the previous one. Each recursive act of writing echoes the way insertion sort works, carefully adding a new piece to the already established sorted narrative.

--