Insertion sort

Insertion sortis a simplesorting algorithmthat builds the finalsorted array(or list) one item at a timeby comparisons.It is much less efficient on large lists than more advanced algorithms such asquicksort,heapsort,ormerge sort.However, insertion sort provides several advantages:

• Simple implementation:Jon Bentleyshows a version that is three lines inC-like pseudo-code, and five lines whenoptimized.
• Efficient for (quite) small data sets, much like other quadratic (i.e.,O(n²)) sorting algorithms
• More efficient in practice than most other simple quadratic algorithms such asselection sortorbubble sort
• Adaptive,i.e., efficient for data sets that are already substantially sorted: thetime complexityisO(kn) when each element in the input is no more thankplaces away from its sorted position
• Stable;i.e., does not change the relative order of elements with equal keys
• In-place;i.e., only requires a constant amount O(1) of additional memory space
• Online;i.e., can sort a list as it receives it

Insertion sort

Insertion sort animation
Class	Sorting algorithm
Data structure	Array
Worst-caseperformance	$O(n^{2})$comparisons and swaps
Best-caseperformance	$O(n)$comparisons,$O(1)$swaps
Averageperformance	$O(n^{2})$comparisons and swaps
Worst-casespace complexity	$O(n)$total,$O(1)$auxiliary
Optimal	No

When people manually sort cards in abridgehand, most use a method that is similar to insertion sort.

Algorithm

A graphical example of insertion sort. The partial sorted list (black) initially contains only the first element in the list. With each iteration one element (red) is removed from the "not yet checked for order" input data and inserted in-place into the sorted list.

Insertion sortiterates,consuming one input element each repetition, and grows a sorted output list. At each iteration, insertion sort removes one element from the input data, finds the location it belongs within the sorted list, and inserts it there. It repeats until no input elements remain.

Sorting is typically done in-place, by iterating up the array, growing the sorted list behind it. At each array-position, it checks the value there against the largest value in the sorted list (which happens to be next to it, in the previous array-position checked). If larger, it leaves the element in place and moves to the next. If smaller, it finds the correct position within the sorted list, shifts all the larger values up to make a space, and inserts into that correct position.

The resulting array afterkiterations has the property where the firstk+ 1 entries are sorted ( "+1" because the first entry is skipped). In each iteration the first remaining entry of the input is removed, and inserted into the result at the correct position, thus extending the result:

becomes

with each element greater thanxcopied to the right as it is compared againstx.

The most common variant of insertion sort, which operates on arrays, can be described as follows:

1. Suppose there exists a function calledInsertdesigned to insert a value into a sorted sequence at the beginning of an array. It operates by beginning at the end of the sequence and shifting each element one place to the right until a suitable position is found for the new element. The function has the side effect of overwriting the value stored immediately after the sorted sequence in the array.
2. To perform an insertion sort, begin at the left-most element of the array and invokeInsertto insert each element encountered into its correct position. The ordered sequence into which the element is inserted is stored at the beginning of the array in the set of indices already examined. Each insertion overwrites a single value: the value being inserted.

Pseudocodeof the complete algorithm follows, where the arrays arezero-based:

i ← 1
whilei < length(A)
j ← i
whilej > 0andA[j-1] > A[j]
swapA[j] and A[j-1]
j ← j - 1
end while
i ← i + 1
end while

The outer loop runs over all the elements except the first one, because the single-element prefixA[0:1]is trivially sorted, so theinvariantthat the firstientries are sorted is true from the start. The inner loop moves elementA[i]to its correct place so that after the loop, the firsti+1elements are sorted. Note that theand-operator in the test must useshort-circuit evaluation,otherwise the test might result in anarray bounds error,whenj=0and it tries to evaluateA[j-1] > A[j](i.e. accessingA[-1]fails).

After expanding theswapoperation in-place asx ← A[j]; A[j] ← A[j-1]; A[j-1] ← x(wherexis a temporary variable), a slightly faster version can be produced that movesA[i]to its position in one go and only performs one assignment in the inner loop body:

i ← 1
whilei < length(A)
x ← A[i]
j ← i
whilej > 0andA[j-1] > x
A[j] ← A[j-1]
j ← j - 1
end while
A[j] ← x
i ← i + 1
end while

The new inner loop shifts elements to the right to clear a spot forx = A[i].

The algorithm can also be implemented in a recursive way. The recursion just replaces the outer loop, calling itself and storing successively smaller values ofnon the stack untilnequals 0, where the function then returns up the call chain to execute the code after each recursive call starting withnequal to 1, withnincreasing by 1 as each instance of the function returns to the prior instance. The initial call would beinsertionSortR(A, length(A)-1).

functioninsertionSortR(array A, int n)
ifn > 0
insertionSortR(A, n-1)
x ← A[n]
j ← n-1
whilej >= 0andA[j] > x
A[j+1] ← A[j]
j ← j-1
end while
A[j+1] ← x
end if
end function

It does not make the code any shorter, it also does not reduce the execution time, but it increases the additional memory consumption fromO(1)toO(N)(at the deepest level of recursion the stack containsNreferences to theAarray, each with accompanying value of variablenfromNdown to 1).

Best, worst, and average cases

The best case input is an array that is already sorted. In this case insertion sort has a linear running time (i.e., O(n)). During each iteration, the first remaining element of the input is only compared with the right-most element of the sorted subsection of the array.

The simplest worst case input is an array sorted in reverse order. The set of all worst case inputs consists of all arrays where each element is the smallest or second-smallest of the elements before it. In these cases every iteration of the inner loop will scan and shift the entire sorted subsection of the array before inserting the next element. This gives insertion sort a quadratic running time (i.e., O(n²)).

The average case is also quadratic,which makes insertion sort impractical for sorting large arrays. However, insertion sort is one of the fastest algorithms for sorting very small arrays, even faster thanquicksort;indeed, goodquicksortimplementations use insertion sort for arrays smaller than a certain threshold, also when arising as subproblems; the exact threshold must be determined experimentally and depends on the machine, but is commonly around ten.

Example: The following table shows the steps for sorting the sequence {3, 7, 4, 9, 5, 2, 6, 1}. In each step, the key under consideration is underlined. The key that was moved (or left in place because it was the biggest yet considered) in the previous step is marked with an asterisk.

37 4 9 5 2 6 1
3*74 9 5 2 6 1
3 7*49 5 2 6 1
3 4* 795 2 6 1
3 4 7 9*52 6 1
3 4 5* 7 926 1
2* 3 4 5 7 961
2 3 4 5 6* 7 91
1* 2 3 4 5 6 7 9

Relation to other sorting algorithms

Insertion sort is very similar toselection sort.As in selection sort, afterkpasses through the array, the firstkelements are in sorted order. However, the fundamental difference between the two algorithms is that insertion sort scans backwards from the current key, while selection sort scans forwards. This results in selection sort making the first k elements theksmallest elements of the unsorted input, while in insertion sort they are simply the firstkelements of the input.

The primary advantage of insertion sort over selection sort is that selection sort must always scan all remaining elements to find the absolute smallest element in the unsorted portion of the list, while insertion sort requires only a single comparison when the(k+ 1)-st element is greater than thek-th element; when this is frequently true (such as if the input array is already sorted or partly sorted), insertion sort is distinctly more efficient compared to selection sort. On average (assuming the rank of the(k+ 1)-st element rank is random), insertion sort will require comparing and shifting half of the previouskelements, meaning that insertion sort will perform about half as many comparisons as selection sort on average.

In the worst case for insertion sort (when the input array is reverse-sorted), insertion sort performs just as many comparisons as selection sort. However, a disadvantage of insertion sort over selection sort is that it requires more writes due to the fact that, on each iteration, inserting the(k+ 1)-st element into the sorted portion of the array requires many element swaps to shift all of the following elements, while only a single swap is required for each iteration of selection sort. In general, insertion sort will write to the array O(n²) times, whereas selection sort will write only O(n) times. For this reason selection sort may be preferable in cases where writing to memory is significantly more expensive than reading, such as withEEPROMorflash memory.

While somedivide-and-conquer algorithmssuch asquicksortandmergesortoutperform insertion sort for larger arrays, non-recursive sorting algorithms such as insertion sort or selection sort are generally faster for very small arrays (the exact size varies by environment and implementation, but is typically between 7 and 50 elements). Therefore, a useful optimization in the implementation of those algorithms is a hybrid approach, using the simpler algorithm when the array has been divided to a small size.

Variants

D.L. Shellmade substantial improvements to the algorithm; the modified version is calledShell sort.The sorting algorithm compares elements separated by a distance that decreases on each pass. Shell sort has distinctly improved running times in practical work, with two simple variants requiring O(n^3/2) and O(n^4/3) running time.

If the cost of comparisons exceeds the cost of swaps, as is the case for example with string keys stored by reference or with human interaction (such as choosing one of a pair displayed side-by-side), then usingbinary insertion sortmay yield better performance.Binary insertion sort employs abinary searchto determine the correct location to insert new elements, and therefore performs⌈log₂n⌉comparisons in the worst case. When each element in the array is searched for and inserted this isO(nlogn).The algorithm as a whole still has a running time of O(n²) on average because of the series of swaps required for each insertion.

The number of swaps can be reduced by calculating the position of multiple elements before moving them. For example, if the target position of two elements is calculated before they are moved into the proper position, the number of swaps can be reduced by about 25% for random data. In the extreme case, this variant works similar tomerge sort.

A variant namedbinary merge sortuses abinary insertion sortto sort groups of 32 elements, followed by a final sort usingmerge sort.It combines the speed of insertion sort on small data sets with the speed of merge sort on large data sets.

To avoid having to make a series of swaps for each insertion, the input could be stored in alinked list,which allows elements to be spliced into or out of the list in constant time when the position in the list is known. However, searching a linked list requires sequentially following the links to the desired position: a linked list does not have random access, so it cannot use a faster method such as binary search. Therefore, the running time required for searching is O(n), and the time for sorting is O(n²). If a more sophisticateddata structure(e.g.,heaporbinary tree) is used, the time required for searching and insertion can be reduced significantly; this is the essence ofheap sortandbinary tree sort.

In 2006 Bender,Martin Farach-Colton,and Mosteiro published a new variant of insertion sort calledlibrary sortorgapped insertion sortthat leaves a small number of unused spaces (i.e., "gaps" ) spread throughout the array. The benefit is that insertions need only shift elements over until a gap is reached. The authors show that this sorting algorithm runs with high probability inO(nlogn)time.

If askip listis used, the insertion time is brought down toO(logn),and swaps are not needed because the skip list is implemented on a linked list structure. The final running time for insertion would beO(nlogn).

List insertion sort code in C

If the items are stored in a linked list, then the list can be sorted with O(1) additional space. The algorithm starts with an initially empty (and therefore trivially sorted) list. The input items are taken off the list one at a time, and then inserted in the proper place in the sorted list. When the input list is empty, the sorted list has the desired result.

structLIST*SortList1(structLIST*pList)
{
// zero or one element in list
if(pList==NULL||pList->pNext==NULL)
returnpList;
// head is the first element of resulting sorted list
structLIST*head=NULL;
while(pList!=NULL){
structLIST*current=pList;
pList=pList->pNext;
if(head==NULL||current->iValue<head->iValue){
// insert into the head of the sorted list
// or as the first element into an empty sorted list
current->pNext=head;
head=current;
}else{
// insert current element into proper position in non-empty sorted list
structLIST*p=head;
while(p!=NULL){
if(p->pNext==NULL||// last element of the sorted list
current->iValue<p->pNext->iValue)// middle of the list
{
// insert into middle of the sorted list or as the last element
current->pNext=p->pNext;
p->pNext=current;
break;// done
}
p=p->pNext;
}
}
}
returnhead;
}

The algorithm below uses a trailing pointerfor the insertion into the sorted list. A simpler recursive method rebuilds the list each time (rather than splicing) and can use O(n) stack space.

structLIST
{
structLIST*pNext;
intiValue;
};

structLIST*SortList(structLIST*pList)
{
// zero or one element in list
if(!pList||!pList->pNext)
returnpList;

/* build up the sorted array from the empty list */
structLIST*pSorted=NULL;

/* take items off the input list one by one until empty */
while(pList!=NULL){
/* remember the head */
structLIST*pHead=pList;
/* trailing pointer for efficient splice */
structLIST**ppTrail=&pSorted;

/* pop head off list */
pList=pList->pNext;

/* splice head into sorted list at proper place */
while(!(*ppTrail==NULL||pHead->iValue<(*ppTrail)->iValue)){/* does head belong here? */
/* no - continue down the list */
ppTrail=&(*ppTrail)->pNext;
}

pHead->pNext=*ppTrail;
*ppTrail=pHead;
}

returnpSorted;
}

Further reading

• Knuth, Donald(1998), "5.2.1: Sorting by Insertion",The Art of Computer Programming,vol. 3. Sorting and Searching (second ed.), Addison-Wesley, pp. 80–105,ISBN0-201-89685-0.

External links

• Animated Sorting Algorithms: Insertion Sortat theWayback Machine(archived 8 March 2015) – graphical demonstration
• Adamovsky, John Paul,Binary Insertion Sort – Scoreboard – Complete Investigation and C Implementation,Pathcom, archived fromthe originalon 2012-02-24,retrieved2009-10-21.
• Insertion Sort – a comparison with other O(n²) sorting algorithms,UK:Core war.
• Insertion sort (C)(wiki), LiteratePrograms– implementations of insertion sort in C and several other programming languages