Sorting algorithms/Selection sort: Difference between revisions

 

First find the smallest element in the array and exchange it with the element in the first position, then find the second smallest element and exchange it with the element in the second position, and continue in this way until the entire array is sorted.

 

=={{header|Ada}}==

 

procedure Test_Selection_Sort is

Put (Integer'Image (A (I)) & " ");

end loop;

<pre>

-5 -2 0 1 3 4 6 7 8 9

{{works with|ALGOL 68G|Any - tested with release mk15-0.8b.fc9.i386}}

{{works with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release 1.8.8d.fc9.i386}}

 

PROC in place selection sort = (REF[]DATA a)VOID:

in place selection sort(ref data);

FOR i TO UPB ref data DO print(ref data[i]) OD; print(new line);

<pre>

abcdefghiijklmnopqrstuvwxyz

big fjords vex quick waltz nymph

</pre>

=={{header|AutoHotkey}}==

ahk forum: [http://www.autohotkey.com/forum/topic44657-105.html discussion]

MsgBox % SelecSort("xxx")

MsgBox % SelecSort("3,2,1")

sorted .= "," . a%A_Index%

Return SubStr(sorted,2) ; drop leading comma

 

=={{header|AWK}}==

{

min = gl[gi]

print line[i]

}

 

 

 

 

 

 

 

 

 

<pre>

</pre>

 

 

 

}

}

}

 

 

=={{header|Common Lisp}}==

 

(do ((length (length array))

(i 0 (1+ i)))

(etypecase sequence

(list (selection-sort-list sequence predicate))

 

Example use:

> (selection-sort (vector 8 7 4 3 2 0 9 1 5 6) '>)

#(9 8 7 6 5 4 3 2 1 0)</pre>

 

=={{header|D}}==

 

 

 

}

}

}

 

void main() {

}

 

=={{header|E}}==

 

def cswap(c, a, b) {

def t := c[a]

}

}

 

=={{header|Forth}}==

 

: least ( start end -- least )

array 10 selection

 

=={{header|Fortran}}==

{{works with|Fortran|95 and later}}

 

IMPLICIT NONE

END SUBROUTINE Selection_sort

 

<pre>

Unsorted array: 4 9 3 -2 0 7 -5 1 6 8

Sorted array : -5 -2 0 1 3 4 6 7 8 9

</pre>

 

=={{header|Haskell}}==

 

=={{header|J}}==

Create the following script and load it to a J session.

 

In an email discussion, Roger_Hui presented the following tacit code:

 

To validate:

6 15 19 12 14 19 0 17 0 14

selectionSort data

0 0 6 12 14 14 15 17 19 19

ss1 data

 

=={{header|Java}}==

This algorithm sorts in place. The call <tt>sort(array)</tt> will rearrange the array and not create a new one.

for(int currentPlace = 0;currentPlace<nums.length-1;currentPlace++){

int smallest = Integer.MAX_VALUE;

nums[smallestAt] = temp;

}

}

 

=={{header|MAXScript}}==

(

local min = undefined

 

data = selectionSort #(4, 9, 3, -2, 0, 7, -5, 1, 6, 8)

</pre>

 

=={{header|OCaml}}==

[] -> []

| first::lst ->

| x::xs -> select_r small (x::output) xs

in

 

=={{header|Perl}}==

{{trans|Tcl}}

{my @a = @_;

foreach my $i (0 .. $#a - 1)

$a[$_] < $a[$min] and $min = $_ foreach $min .. $#a;

$a[$i] > $a[$min] and @a[$i, $min] = @a[$min, $i];}

 

=={{header|Python}}==

 

mn = min(range(i,len(lst)), key=lst.__getitem__)

 

=={{header|R}}==

For loop:

{

lenx <- length(x)

}

x

Recursive:

 

(A prettier solution, but, you may need to increase the value of options("expressions") to test it. Also, you may get a stack overflow if the length of the input vector is more than a few thousand.)

{

if(length(x) > 1)

c(x[mini], selectionsort(x[-mini]))

} else x

}

 

=={{header|Ruby}}==

end

end

end

end

 

=={{header|Standard ML}}==

| selection_sort (first::lst) =

let

if x < small then

else

in

 

=={{header|Tcl}}==

package require struct::list

 

}

 

 

=={{header|Ursala}}==

is deleted from the list and inserted into another on each iteration

rather than swapped with a preceding item of the same list.

 

This is already a bad way to code a sorting algorithm in this

language, but with only a bit more work, we can get a bigger and

slower version that more closely simulates the operations of

repeatedly reordering an array.

Here is a test program sorting by the partial order relation on natural

numbers.

#cast %nL

 

<pre><220,240,263,294,348,392,473,596,621,815></pre>