Selection sort

Here is an example of this sort algorithm sorting five elements:

Selection sort animation. Red is current min. Yellow is sorted list. Blue is current item.

(Nothing appears changed on these last two lines because the last two numbers were already in order.)

Selection sort can also be used on list structures that make add and remove efficient, such as a linked list. In this case it is more common to remove the minimum element from the remainder of the list, and then insert it at the end of the values sorted so far. For example:

arr[] = 64 25 12 22 11

// Find the minimum element in arr[0...4]
// and place it at beginning
11 25 12 22 64

// Find the minimum element in arr[1...4]
// and place it at beginning of arr[1...4]
11 12 25 22 64

// Find the minimum element in arr[2...4]
// and place it at beginning of arr[2...4]
11 12 22 25 64

// Find the minimum element in arr[3...4]
// and place it at beginning of arr[3...4]
11 12 22 25 64 

Below is an implementation in C. More implementations can be found on the talk page of this Wikipedia article.

 1 /* a[0] to a[aLength-1] is the array to sort */
 2 int i,j;
 3 int aLength; // initialise to a's length
 4 
 5 /* advance the position through the entire array */
 6 /*   (could do i < aLength-1 because single element is also min element) */
 7 for (i = 0; i < aLength-1; i++)
 8 {
 9     /* find the min element in the unsorted a[i .. aLength-1] */
10 
11     /* assume the min is the first element */
12     int jMin = i;
13     /* test against elements after i to find the smallest */
14     for (j = i+1; j < aLength; j++)
15     {
16         /* if this element is less, then it is the new minimum */
17         if (a[j] < a[jMin])
18         {
19             /* found new minimum; remember its index */
20             jMin = j;
21         }
22     }
23 
24     if (jMin != i) 
25     {
26         swap(a[i], a[jMin]);
27     }
28 }

Selection sort is not difficult to analyze compared to other sorting algorithms since none of the loops depends on the data in the array. Selecting the minimum requires scanning ${\displaystyle n}$ elements (taking ${\displaystyle n-1}$ comparisons) and then swapping it into the first position. Finding the next lowest element requires scanning the remaining ${\displaystyle n-1}$ elements and so on. Therefore, the total number of comparisons is

${\displaystyle (n-1)+(n-2)+...+1=\sum _{i=1}^{n-1}i}$

By arithmetic progression,

${\displaystyle \sum _{i=1}^{n-1}i={\frac {(n-1)+1}{2}}(n-1)={\frac {1}{2}}n(n-1)={\frac {1}{2}}(n^{2}-n)}$

which is of complexity ${\displaystyle O(n^{2})}$ in terms of number of comparisons. Each of these scans requires one swap for ${\displaystyle n-1}$ elements (the final element is already in place).

Among quadratic sorting algorithms (sorting algorithms with a simple average-case of Θ(n²)), selection sort almost always outperforms bubble sort and gnome sort. Insertion sort is very similar in that after the kth iteration, the first k elements in the array are in sorted order. Insertion sort's advantage is that it only scans as many elements as it needs in order to place the k + 1st element, while selection sort must scan all remaining elements to find the k + 1st element.

Simple calculation shows that insertion sort will therefore usually perform about half as many comparisons as selection sort, although it can perform just as many or far fewer depending on the order the array was in prior to sorting. It can be seen as an advantage for some real-time applications that selection sort will perform identically regardless of the order of the array, while insertion sort's running time can vary considerably. However, this is more often an advantage for insertion sort in that it runs much more efficiently if the array is already sorted or "close to sorted."

While selection sort is preferable to insertion sort in terms of number of writes (Θ(n) swaps versus Ο(n²) swaps), it almost always far exceeds (and never beats) the number of writes that cycle sort makes, as cycle sort is theoretically optimal in the number of writes. This can be important if writes are significantly more expensive than reads, such as with EEPROM or Flash memory, where every write lessens the lifespan of the memory.

Finally, selection sort is greatly outperformed on larger arrays by Θ(n log n) divide-and-conquer algorithms such as mergesort. However, insertion sort or selection sort are both typically faster for small arrays (i.e. fewer than 10–20 elements). A useful optimization in practice for the recursive algorithms is to switch to insertion sort or selection sort for "small enough" sublists.

Heapsort greatly improves the basic algorithm by using an implicit heap data structure to speed up finding and removing the lowest datum. If implemented correctly, the heap will allow finding the next lowest element in Θ(log n) time instead of Θ(n) for the inner loop in normal selection sort, reducing the total running time to Θ(n log n).

A bidirectional variant of selection sort (sometimes called cocktail sort due to its similarity to the bubble-sort variant cocktail shaker sort) is an algorithm which finds both the minimum and maximum values in the list in every pass. This reduces the number of scans of the input by a factor of two. Each scan performs three comparisons per two elements (a pair of elements is compared, then the greater is compared to the maximum and the lesser is compared to the minimum), a 25% savings over regular selection sort, which does one comparison per element. Sometimes this is double selection sort.

Selection sort can be implemented as a stable sort. If, rather than swapping in step 2, the minimum value is inserted into the first position (that is, all intervening items moved down), the algorithm is stable. However, this modification either requires a data structure that supports efficient insertions or deletions, such as a linked list, or it leads to performing Θ(n²) writes.

In the bingo sort variant, items are ordered by repeatedly looking through the remaining items to find the greatest value and moving all items with that value to their final location.[1] Like counting sort, this is an efficient variant if there are many duplicate values. Indeed, selection sort does one pass through the remaining items for each item moved. Bingo sort does one pass for each value (not item): after an initial pass to find the biggest value, the next passes can move every item with that value to its final location while finding the next value as in the following pseudocode (arrays are zero-based and the for-loop includes both the top and bottom limits, as in Pascal):

bingo(array A)

{ This procedure sorts in ascending order. }
begin
    max := length(A)-1;

    { The first iteration is written to look very similar to the subsequent ones, but
      without swaps. }
    nextValue := A[max];
    for i := max - 1 downto 0 do
        if A[i] > nextValue then
            nextValue := A[i];
    while (max > 0) and (A[max] = nextValue) do
        max := max - 1;

    while max > 0 do begin
        value := nextValue;
        nextValue := A[max];
        for i := max - 1 downto 0 do
             if A[i] = value then begin
                 swap(A[i], A[max]);
                 max := max - 1;
             end else if A[i] > nextValue then
                 nextValue := A[i];
        while (max > 0) and (A[max] = nextValue) do
            max := max - 1;
    end;
end;

Thus, if on average there are more than two items with the same value, bingo sort can be expected to be faster because it executes the inner loop fewer times than selection sort.

• Selection algorithm

The Wikibook Algorithm implementation has a page on the topic of: Selection sort

• Animated Sorting Algorithms: Selection Sort at the Wayback Machine (archived 7 March 2015) – graphical demonstration