选择排序

C语言

1 void selection_sort(int a[], int len) 
 2 { 3     int i,j,temp; 4  5 for (i = 0 ; i < len - 1 ; i++) 
 6     { 7 int min = i; 8 for (j = i + 1; j < len; j++)     //走訪未排序的元素 9 {10 if (a[j] < a[min])    //找到目前最小值11 {12 min = j;    //紀錄最小值13 }14 }15 temp=a[min];  //交換兩個變數16 a[min]=a[i];17 a[i]=temp;18    /* swap(&a[min], &a[i]);  */   //做交換19 }20 }21 22 /*23 void swap(int *a,int *b) //交換兩個變數24 {25     int temp = *a;26     *a = *b;27     *b = temp;28 }29 */

C++

template<typename T> //整數或浮點數皆可使用，若要使用物件（class）時必須設定大於（>）的運算子功能void selection_sort(std::vector<T>& arr) {
for (int i = 0; i < arr.size() - 1; i++) {
int min = i;
for (int j = i + 1; j < arr.size(); j++)
if (arr[j] < arr[min])
min = j;
std::swap(arr[i], arr[min]);
}}

C#

static void selection_sort<T>(T[] arr) where T : System.IComparable<T>{//整數或浮點數皆可使用
int i, j, min, len = arr.Length;
T temp;
for (i = 0; i < len - 1; i++) {
min = i;
for (j = i + 1; j < len; j++)
if (arr[min].CompareTo(arr[j]) > 0)
min = j;
temp = arr[min];
arr[min] = arr[i];
arr[i] = temp;
}}

VB.net

'進行排序前先建構兩數值交換的程式switch
   Private Sub switch(ByRef a, ByRef b)
       Dim c As Integer
       c = a: a = b: b = c
   End Sub
   
   Private Sub(ByRef Data() as Decimal)
   '選擇排序由小到大Dim i, j, count As Integer
       Dim minIndex As Integer
       For i = 0 To UBound(Data) - 2
           minIndex =i
           For j = i + 1 To UBound(Data)-1
               If Data(minIndex) > Data(j) Then 
                   minIndex =j
               end if
           Next 
           if i<> minIndex then
                 switch(Data(i), Data(minIndex))
                 count += 1
           end if
       Next
       MsgBox("一共經過了" & count & "次的排序")
  End Sub

Python

def selection_sort(arr):
    for i in range(len(arr)-1):
        minIndex=i
        for j in range(i+1,len(arr)):
            if arr[minIndex]>arr[j]:
                minIndex=j
        if i==minIndex:
            pass
        else:
            arr[i],arr[minIndex]=arr[minIndex],arr[i]
    return arrif __name__ == '__main__':
    testlist = [17, 23, 20, 14, 12, 25, 1, 20, 81, 14, 11, 12]
    print(selection_sort(testlist))

Java

1     public static void selectionSort(Comparable[] a) { 2         int N =a.length; 3         for (int i = 0; i < N-1; i++) { 4             int min = i; 5             for (int j = i+1; j < N; j++) { 6                 if (less(a[j], a[min])) min = j; 7             } 8             exch(a, i, min); 9         }10     }11 12     private static boolean less(Comparable v, Comparable w) {13         return v.compareTo(w) < 0;14     }15 16     private static void exch(Comparable[] a, int i, int j) {17         Comparable t = a[i];18         a[i] = a[j];19         a[j] = t;20     }

JavaScript

Array.prototype.selection_sort = function() {
  var i, j, min;
  var temp;
  for (i = 0; i < this.length-1; i++) {
    min = i;
    for (j = i + 1; j < this.length; j++) {
      if (this[min] > this[j]) {
        min = j;
      }
    }

    temp = this[min];
    this[min] = this[i];
    this[i] = temp;
  }
  return this;};

PHP

function swap(&$x, &$y) {
$t = $x;
$x = $y;
$y = $t;}function selection_sort(&$arr) {//php的陣列視為基本型別，所以必須用傳參考才能修改原陣列
for ($i = 0; $i < count($arr) - 1; $i++) {
$min = $i;
for ($j = $i + 1; $j < count($arr); $j++)
if ($arr[$min] > $arr[$j])
$min = $j;
swap($arr[$min], $arr[$i]);
}}

GO

1 // SelectionSort 选择排序, data必须实现sort包中的Interface接口 2 func SelectionSort(data sort.Interface) { 3  4 for i := 0; i < data.Len()-1; i++ { 5 // 假定首元素为最小元素 6 min := i 7 for j := min + 1; j < data.Len(); j++ { 8 if data.Less(j, min) { 9 min = j10 }11 }12 // 将此次筛选出的最小元素放入最左边13     if min != i {14     data.Swap(min, i)15     }16 }17 }

Swift

import Foundation/// 选择排序////// - Parameter list: 需要排序的数组func selectionSort(_ list: inout [Int]) -> Void {
    for j in 0..<list.count - 1 {
        var minIndex = j
        for i in j..<list.count {
            if list[minIndex] > list[i] {
                minIndex = i
            }
        }
        list.swapAt(j, minIndex)
    }}

复杂度分析

选择排序的交换操作介于和次之间。选择排序的比较操作为次。选择排序的赋值操作介于和次之间。

比较次数，比较次数与关键字的初始状态无关，总的比较次数。交换次数，最好情况是，已经有序，交换0次；最坏情况是，逆序，交换次。交换次数比冒泡排序较少，由于交换所需CPU时间比比较所需的CPU时间多，值较小时，选择排序比冒泡排序快。
原地操作几乎是选择排序的唯一优点，当空间复杂度要求较高时，可以考虑选择排序；实际适用的场合非常罕见。