Among the three simple sorting algorithms with quadratic time complexity, the Insertion Sort have sove special qualities, of which probably few most important are:
Let's see how it works.
Suppose we have some sub-array (or list) already sorted. How hard would it be to add one more element to it, keeping data still ordered?
We should search through initial sub-array and find a place where new element should be inserted. To insert it we, of course, need to shift all elements which are larger. See an example:
1 3 5 6 8 - initial array 4 - another element to add
Searching through array we see that
4 should be inserted where
5 currently is. Let us shift all elements starting
1 3 _ 5 6 8 - we shift the upper part of array 1 3 4 5 6 8 - and insert new element to empty cell
Now it is easy to create a method for sorting the whole array!
Starting with unordered list of elements, like this:
[3, 1, 2, 5]
Let the very first element be our "initial ordered sub-array". Obviously array of a single element is always ordered :)
, 1, 2, 5
Now at each step we'll be inserting into the "current sub-array" one element immediately following it. On the first
step we are going to insert
1, we can do it as following:
Tto the proper place in updated sub-array.
So the process will go like this:
, 1, 2, 5 T = 1, it should be inserted before 3 [3, 3], 2, 5 part of array starting from 3 is shifted, 1 is overwritten [1, 3], 2, 5 1 is restored from T to the proper place [1, 3], 2, 5 T = 2, it should be inserted before 3 [1, 3, 3], 5 part of array starting from 3 is shifted, 2 is overwritten [1, 2, 3], 5 2 is inserted from T to sub-array [1, 2, 3], 5 T = 5, it should be inserted... after all other elements, nice! [1, 2, 3, 5] nothing to shift! we just extend sub-array to have 5 in it.
Comparing to Selection Sort we can see that more moves (copying) of array elements is performed, but probably less comparisons. So benefit of the Insertion Sort is for objects which are handled by references (as in most contemporary languages) but for which comparison takes significant time.
Since we are always searching through already sorted sub-array, we can use a kind of Binary Search here, which will allow to decrease the amount of comparisons dramatically.
We can also perform "shift" in lazy way - simply making swaps of currently inserted element with all preceding ones until it is less than they. It makes the algorithm resemble bubble-sort and decreases its efficiency, but greatly simplifies implementation.
You are given an array of values to sort. Implement the described algorithm and at each pass print out how many elements of the array were shifted.
Input data will contain
N - the size of array - in the first line.
Next line will contain the array itself (all elements will be different).
Answer should contain
N-1 values showing how much elements are shifted at each pass.
input data: 4 3 1 2 5 answer: 1 1 0