|
|
| (One intermediate revision by one other user not shown) |
| Line 1: |
Line 1: |
| {{Infobox Algorithm
| | Butcher or Smallgoods Maker Earl from Burgessville, has lots of interests that include electronics, [http://natasasrnka2213.tumblr.com/post/95633022071/growtopia-hack-tool-android-ios Growtopia Hack] and crafts. Has become stimulated how big the earth is after making a journey to Temple of Heaven: an Imperial Sacrificial Altar in Beijing. |
| |class=[[Sorting algorithm]]
| |
| |image=[[Image:Selection sort animation.gif|none|288px|Selection sort animation.]]
| |
| |data=[[Array data structure|Array]]
| |
| |time=О(''n''<sup>2</sup>)
| |
| |best-time=О(''n''<sup>2</sup>)
| |
| |average-time=О(''n''<sup>2</sup>)
| |
| |space=О(''n'') total, O(1) auxiliary
| |
| |optimal=No
| |
| }}
| |
| [[Image:Selection-Sort-Animation.gif|right|thumb|Selection sort animation. Red is current min. Yellow is sorted list. Blue is current item.]]
| |
| | |
| In [[computer science]], '''selection sort''' is a [[sorting algorithm]], specifically an [[in-place algorithm|in-place]] [[comparison sort]]. It has [[Big O notation|O]](''n''<sup>2</sup>) time complexity, making it inefficient on large lists, and generally performs worse than the similar [[insertion sort]]. Selection sort is noted for its simplicity, and it has performance advantages over more complicated algorithms in certain situations, particularly where auxiliary memory is limited.
| |
| | |
| The algorithm divides the input list into two parts: the sublist of items already sorted, which is built up from left to right at the front (left) of the list, and the sublist of items remaining to be sorted that occupy the rest of the list. Initially, the sorted sublist is empty and the unsorted sublist is the entire input list. The algorithm proceeds by finding the smallest (or largest, depending on sorting order) element in the unsorted sublist, exchanging it with the leftmost unsorted element (putting it in sorted order), and moving the sublist boundaries one element to the right.
| |
| | |
| Here is an example of this sort algorithm sorting five elements:
| |
| | |
| <pre>
| |
| 64 25 12 22 11
| |
| | |
| 11 25 12 22 64
| |
| | |
| 11 12 25 22 64
| |
| | |
| 11 12 22 25 64
| |
| | |
| 11 12 22 25 64
| |
| </pre>
| |
| (nothing appears changed on this last line because the last 2 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:
| |
| | |
| <pre>
| |
| 64 25 12 22 11
| |
| | |
| 11 64 25 12 22
| |
| | |
| 11 12 64 25 22
| |
| | |
| 11 12 22 64 25
| |
| | |
| 11 12 22 25 64
| |
| </pre>
| |
| | |
| <source lang="C">
| |
| /* a[0] to a[n-1] is the array to sort */
| |
| int i,j;
| |
| int iMin;
| |
| | |
| /* advance the position through the entire array */ | |
| /* (could do j < n-1 because single element is also min element) */
| |
| for (j = 0; j < n-1; j++) {
| |
| /* find the min element in the unsorted a[j .. n-1] */
| |
| | |
| /* assume the min is the first element */
| |
| iMin = j;
| |
| /* test against elements after j to find the smallest */
| |
| for ( i = j+1; i < n; i++) {
| |
| /* if this element is less, then it is the new minimum */
| |
| if (a[i] < a[iMin]) {
| |
| /* found new minimum; remember its index */
| |
| iMin = i;
| |
| }
| |
| }
| |
| | |
| /* iMin is the index of the minimum element. Swap it with the current position */
| |
| if ( iMin != j ) {
| |
| swap(a[j], a[iMin]);
| |
| }
| |
| }
| |
| </source>
| |
| | |
| ==Mathematical definition==
| |
| | |
| Let <math>L</math> be a non-empty [[set (mathematics)|set]] and <math>f : L \to L</math> such that <math>f(L) = L'</math> where:
| |
| | |
| # <math>L'</math> is a [[permutation]] of <math>L</math>,
| |
| # <math>e_i \le e_{i+1}</math> for all <math>e \in L'</math> and <math>i \in \mathbb{N}</math>,
| |
| # <math>f(L) =
| |
| \begin{cases}
| |
| L, & \mbox{if }|L| = 1\\
| |
| \{s\} \cup f(L_{s}), & \mbox{otherwise}
| |
| \end{cases}</math>,
| |
| # <math>s</math> is [[maxima and minima|the smallest element]] of <math>L</math>, and
| |
| # <math>L_s</math> is the set of elements of <math>L</math> without one instance of the smallest element of <math>L</math>.
| |
| | |
| == Analysis ==
| |
| Selection sort is not difficult to analyze compared to other sorting algorithms since none of the loops depend on the data in the array. Selecting the lowest element requires scanning all ''n'' elements (this takes ''n'' − 1 comparisons) and then swapping it into the first position. Finding the next lowest element requires scanning the remaining ''n'' − 1 elements and so on, for (''n'' − 1) + (''n'' − 2) + ... + 2 + 1 = ''n''(''n'' − 1) / 2 ∈ Θ(''n''<sup>2</sup>) comparisons (see [[arithmetic progression]]). Each of these scans requires one swap for ''n'' − 1 elements (the final element is already in place).
| |
| | |
| ==Comparison to other sorting algorithms==
| |
| | |
| Among simple average-case Θ(''n''<sup>2</sup>) algorithms, selection sort almost always outperforms [[bubble sort]] and [[gnome sort]]. Insertion sort is very similar in that after the ''k''th 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 computing|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''<sup>2</sup>) 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|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 algorithm|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.
| |
| | |
| == Variants ==
| |
| | |
| [[Heapsort]] greatly improves the basic algorithm by using an [[implicit data structure|implicit]] [[heap (data structure)|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, called '''cocktail 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 list by a factor of 2, eliminating some loop overhead but not actually decreasing the number of comparisons or swaps. Note, however, that [[cocktail sort]] more often refers to a bidirectional variant of bubble sort.
| |
| | |
| Selection sort can be implemented as a [[Sorting algorithm#Classification|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''<sup>2</sup>) 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.<ref>{{DADS|Bingo sort|bingosort}}</ref> 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 (programming language)|Pascal]]):
| |
| | |
| <source lang="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;
| |
| </source>
| |
| | |
| 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.
| |
| <!--
| |
| | |
| If you came here to write an implementation of selection sort, note that this page used to have implementations but they were moved to Wikibooks. Therefore, implementations should not be added here.
| |
| | |
| -->
| |
| | |
| == See also ==
| |
| * [[Selection algorithm]]
| |
| | |
| == References ==
| |
| {{reflist}}
| |
| {{refbegin}}
| |
| * [[Donald Knuth]]. ''The Art of Computer Programming'', Volume 3: ''Sorting and Searching'', Third Edition. Addison–Wesley, 1997. ISBN 0-201-89685-0. Pages 138–141 of Section 5.2.3: Sorting by Selection.
| |
| * Anany Levitin. ''Introduction to the Design & Analysis of Algorithms'', 2nd Edition. ISBN 0-321-35828-7. Section 3.1: Selection Sort, pp 98–100.
| |
| * [[Robert Sedgewick (computer scientist)|Robert Sedgewick]]. ''Algorithms in C++, Parts 1–4: Fundamentals, Data Structure, Sorting, Searching: Fundamentals, Data Structures, Sorting, Searching Pts. 1–4'', Second Edition. Addison–Wesley Longman, 1998. ISBN 0-201-35088-2. Pages 273–274
| |
| {{refend}}
| |
| | |
| == External links ==
| |
| {{wikibooks|Algorithm implementation|Sorting/Selection_sort|Selection sort}}
| |
| * [http://www.sorting-algorithms.com/selection-sort Animated Sorting Algorithms: Selection Sort] – graphical demonstration and discussion of selection sort
| |
| | |
| {{sorting}}
| |
| [[Category:Sorting algorithms]]
| |
| [[Category:Comparison sorts]]
| |
Butcher or Smallgoods Maker Earl from Burgessville, has lots of interests that include electronics, Growtopia Hack and crafts. Has become stimulated how big the earth is after making a journey to Temple of Heaven: an Imperial Sacrificial Altar in Beijing.