Algorithm Implementation/Sorting/Selection sort

This article describes implementations of the selection sort sorting algorithm in a variety of real-world programming languages.

BASIC

For i = 1 To n - 1
   min = i
   For j = i + 1 To n
      If x(min) > x(j) Then
         min = j
      End If
   Next j
   temp = x(i)
   x(i) = x(min)
   x(min) = temp
Next

C/C++

void selection(int *array, int length)
{
    int max, i, temp;
    while (length > 0)
    {
        max = 0;
        for (i = 1; i < length; i++)
            if (array[i] > array[max])
                max = i;

        temp = array[length-1];
        array[length-1] = array[max];
        array[max] = temp;
        length--;
    }
}

C

This is an implementation of the unstable variant:

int selectionSort(int data[], int count)
{
    int i, j;
    int tmp;
    int minimum;
    for (i = 0; i < count - 1; i++)
    {
        minimum = i; /* current minimum */

        /* find the global minimum */
        for (j = i + 1; j < count; j++)
            if (data[minimum] > data[j])
                minimum = j; /* new minimum */

        /* swap data[i] and data[minimum] */
        tmp = data[i];
        data[i] = data[minimum];
        data[minimum] = tmp;
    }
    return 0;
}

This is an implementation of the stable variant:

void selectionSort(int data[], int count)
{
    int i, j, m, mi;
    for (i = 0; i < count - 1; i++)
    {
        /* find the minimum */
        mi = i;
        for (j = i + 1; j < count; j++)
            if (data[j] < data[mi])
                mi = j;

        m = data[mi];

        /* move elements to the right */
        for (j = mi; j > i; j--)
            data[j] = data[j-1];

        data[i] = m;
    }
}

C++

#include <algorithm> // for: std::iter_swap, std::min_element

template <typename Iterator>
void selection_sort(Iterator begin, Iterator end)
{
    Iterator min;
    while (begin != end)
    {
        min = std::min_element(begin, end);
        std::iter_swap(begin, min);
        ++begin;
    }
}

C#

public void sortArray(int[] intArray)
{
    int min, temp;

    for (int i = 0; i < intArray.Length - 1; i++)
    {
        min = i;
        for (int j = i + 1; j < intArray.Length; j++)
            if (intArray[j] < intArray[min])
                min = j;

        // swap the values
        temp = intArray[i];
        intArray[i] = intArray[min];
        intArray[min] = temp;
    }
}

Java

An iterative implementation:

public static int[] selectionsort(int[] numbers)
{
    for (int i = 0; i < numbers.length - 1; i++)
    {
        int index = i;
        for (int j = i + 1; j < numbers.length; j++)
            if (numbers[j] < numbers[index]) //Finds smallest number
                index = j;

        int smallerNumber = numbers[index];  //Swap
        numbers[index] = numbers[i];
        numbers[i] = smallerNumber;

    }
    return numbers;
}

A recursive implementation:

public static int findMin(int[] array, int index)
{
    int min = index - 1;
    if (index < array.length - 1)
        min = findMin(array, index + 1);
    if (array[index] < array[min])
        min = index;
    return min;
}

public static void selectionSort(int[] array)
{
    selectionSort(array, 0);
}

public static void selectionSort(int[] array, int left)
{
    if (left < array.length - 1)
    {
        swap(array, left, findMin(array, left));
        selectionSort(array, left+1);
    }
}

public static void swap(int[] array, int index1, int index2)
{
    int temp = array[index1];
    array[index1] = array[index2];
    array[index2] = temp;
}

JavaScript

function selectionSort (sortMe)
{
    var i, j, tmp, tmp2;
    for (i = 0; i < sortMe.length - 1; i++)
    {
        tmp = i;
        for (j = i + 1; j < sortMe.length; j++){
            if (sortMe[j] < sortMe[tmp]){
                tmp = j;
            }
        }
        if(tmp!=i){
            tmp2 = sortMe[tmp];
            sortMe[tmp] = sortMe[i];
            sortMe[i] = tmp2;
        }
    }
}

ML

(* Selection sort is modified slightly for use on linked lists (which are the only inbuilt array-like structures in ML)
      in a functional programming language *)
fun selection_sort [] = []
|   selection_sort (first::lst) =
    let
      fun select_r small ([], output) = small::(selection_sort output)
      |   select_r small (x::xs, output) =
            if (x< small) then
              select_r x (xs, small::output)
            else
              select_r small (xs, x::output)
    in
      select_r first (lst, [])
    end
;

Ocaml

(* Gets the minimum element of the list *)
let rec min lst =
    match lst with
       x::[] -> x
     | (x::tl) -> let mintl = min tl in
                    if x < mintl then x else mintl;;

(* Removes a given element from the list *)
let rec remove(x,lst) =
    match lst with
       [] -> []
     | (y::tl) -> if x=y then tl else y::(remove(x,tl));;

(* Sorts a list by repeatedly extracting the minimum *)
let rec selectionSort(lst) =
    match lst with
       [] -> []
     | _  -> let m = min lst in m::(selectionSort(remove(m,lst)));;

Phix

function selection_sort(sequence s)
integer m
    for i=1 to length(s) do
        m = i
        for j=i+1 to length(s) do
            if s[j]<s[m] then
                m = j
            end if
        end for
        {s[i],s[m]} = {s[m],s[i]}
    end for
    return s
end function

PHP

function selectionSort(&$a)
{
    $n = count($a);
    for ($i = 0; $i < $n - 1; $i++)
    {
        $min = $i;
        for ($j = $i + 1; $j < $n; $j++)
            if ($a[$j] < $a[$min])
                $min = $j;

        list($a[$i], $a[$min]) = array($a[$min], $a[$i]);
    }
}

Python

newList = [6,7,4,5,1]
for outer in range(len(newList)):
    minimum = min(newList[outer:]) #find minimum element
    minIndex = newList[outer:].index(minimum) #find index of minimum element
    newList[outer + minIndex] = newList[outer] #replace element at minIndex with first element
    newList[outer] = minimum #replace first element with min element
print newList

Ruby

  def sort!(keys)
    for i in 0..keys.size-2
      min = i
      for j in i+1..keys.size-1
        min = j if keys[j] < keys[min]
        end
      keys[i], keys[min] = keys[min], keys[i]
      end
    keys
  end