Sort an integer array

Sort an array (or list) of integers in ascending numerical order. Use a sorting facility provided by the language/library if possible.

4D

English

<lang 4d>ARRAY INTEGER($nums;0) APPEND TO ARRAY($nums;2) APPEND TO ARRAY($nums;4) APPEND TO ARRAY($nums;3) APPEND TO ARRAY($nums;1) APPEND TO ARRAY($nums;2) SORT ARRAY($nums) ` sort in ascending order SORT ARRAY($nums;<) ` sort in descending order</lang>

Français

<lang 4d>TABLEAU ENTIER($nombres;0) AJOUTER A TABLEAU($nombres;2) AJOUTER A TABLEAU($nombres;4) AJOUTER A TABLEAU($nombres;3) AJOUTER A TABLEAU($nombres;1) AJOUTER A TABLEAU($nombres;2) TRIER TABLEAU($nombres) ` pour effectuer un tri par ordre croissant TRIER TABLEAU($nombres;<) ` pour effectuer un tri par ordre décroissant</lang>

ActionScript

<lang ActionScript>//Comparison function must returns Numbers even though it deals with integers. function compare(x:int, y:int):Number { return Number(x-y); } var nums:Vector.<int> = Vector.<int>([5,12,3,612,31,523,1,234,2]); nums.sort(compare);</lang>

Ada

Works with: GNAT version GPL 2006

<lang ada>with Gnat.Heap_Sort_G;

procedure Integer_Sort is

  -- Heap sort package requires data to be in index values starting at
  -- 1 while index value 0 is used as temporary storage
  type Int_Array is array(Natural range <>) of Integer;
  Values : Int_Array := (0,1,8,2,7,3,6,4,5);
  
  -- define move and less than subprograms for use by the heap sort package
  procedure Move_Int(From : Natural; To : Natural) is
  begin
     Values(To) := Values(From);
  end Move_Int;
  
  function Lt_Int(Left, Right : Natural) return Boolean is
  begin
     return Values(Left) < Values (Right);
  end Lt_Int;
 
  -- Instantiate the generic heap sort package
  package Heap_Sort is new Gnat.Heap_Sort_G(Move_Int, Lt_Int);

begin

  Heap_Sort.Sort(8);

end Integer_Sort;

requires an Ada05 compiler, e.g GNAT GPL 2007 with Ada.Containers.Generic_Array_Sort;

procedure Integer_Sort is

  -- 
  type Int_Array is array(Natural range <>) of Integer;
  Values : Int_Array := (0,1,8,2,7,3,6,4,5);
  
  -- Instantiate the generic sort package from the standard Ada library
  procedure Sort is new Ada.Containers.Generic_Array_Sort
    (Index_Type   => Natural;
     Element_Type => Integer;
     Array_Type   => Int_Array);

begin

  Sort(Values);

end Integer_Sort;</lang>

ALGOL 68

Translation of: python

Works with: ALGOL 68 version Standard - no extensions to language used

Works with: ALGOL 68G version Any - tested with release mk15-0.8b.fc9.i386

Works with: ELLA ALGOL 68 version Any (with appropriate job cards) - tested with release 1.8.8d.fc9.i386

<lang algol68>CO PR READ "shell_sort.a68" PR CO MODE TYPE = INT;

PROC in place shell sort = (REF[]TYPE seq)REF[]TYPE:(

   INT inc := ( UPB seq + LWB seq + 1 ) OVER 2;
   WHILE inc NE 0 DO
       FOR index FROM LWB seq TO UPB seq DO
           INT i := index;
           TYPE el = seq[i];
           WHILE ( i  - LWB seq >= inc | seq[i - inc] > el | FALSE ) DO
               seq[i] := seq[i - inc];
               i -:= inc
           OD;
           seq[i] := el
       OD;
       inc := IF inc = 2 THEN 1 ELSE ENTIER(inc * 5 / 11) FI
   OD;  
   seq

);

PROC shell sort = ([]TYPE seq)[]TYPE:

 in place shell sort(LOC[LWB seq: UPB seq]TYPE:=seq);

print((shell sort((2, 4, 3, 1, 2)), new line))</lang> Output:

         +1         +2         +2         +3         +4

APL

Works with: APL2

<lang apl> X←63 92 51 92 39 15 43 89 36 69

     X[⍋X]

15 36 39 43 51 63 69 89 92 92</lang>

AutoHotkey

<lang AutoHotkey>numbers = 5 4 1 2 3 sort, numbers, N D%A_Space% Msgbox % numbers</lang>

C

Works with: gcc version 4.0.1

<lang c>#include <stdlib.h>

int intcmp(const void *a, const void *b) {

   return *(int *)a - *(int *)b;

}

int main() {

   int nums[5] = {2,4,3,1,2};
   qsort(nums, 5, sizeof(int), intcmp);

}</lang>

C++

Works with: g++ version 4.0.1

Simple Array

<lang cpp>#include <algorithm>

int main() {

   int nums[] = {2,4,3,1,2};
   std::sort(nums, nums+5);

}</lang>

`std::vector`

<lang cpp>#include <algorithm>

include <vector>

int main() {

   std::vector<int> nums;
   nums.push_back(2);
   nums.push_back(4);
   nums.push_back(3);
   nums.push_back(1);
   nums.push_back(2);
   std::sort(nums.begin(), nums.end());

}</lang>

`std::list`

<lang cpp>#include <list>

int main() {

   std::list<int> nums;
   nums.push_back(2);
   nums.push_back(4);
   nums.push_back(3);
   nums.push_back(1);
   nums.push_back(2);
   nums.sort();

}</lang>

C#

<lang csharp>using System; using System.Collections.Generic;

public class Program {

   static void Main() {
       int[] unsorted = { 6, 2, 7, 8, 3, 1, 10, 5, 4, 9 };
       Array.Sort(unsorted);
   }

}</lang>

Clean

We use list and array comprehensions to convert an array to and from a list in order to use the built-in sort on lists. <lang clean>import StdEnv

sortArray :: (a e) -> a e | Array a e & Ord e sortArray array = {y \\ y <- sort [x \\ x <-: array]}

Start :: {#Int} Start = sortArray {2, 4, 3, 1, 2}</lang>

Clojure

<lang clojure>(sort [5 4 3 2 1]) ; sort can also take a comparator function (1 2 3 4 5)</lang>

Common Lisp

In Common Lisp, the sort function takes a predicate that is used as the comparator. This parameter can be any two-argument function. To sort a sequence (list or array) of integers, call sort with the < operator as the predicate: <lang lisp>CL-USER> (sort #(9 -2 1 2 8 0 1 2) #'<)

(-2 0 1 1 2 2 8 9)</lang>

D

<lang d>auto nums = [2,4,3,1,2]; auto snums = nums.dup.sort; // Sort nums.sort; // Sort in-place</lang>

E

Erlang

<lang erlang>List = [2, 4, 3, 1, 2]. SortedList = lists:sort(List).</lang>

Factor

<lang factor>{ 1 4 9 2 3 0 5 } natural-sort .</lang>

Forth

Works with: Win32Forth version 4.2

<lang forth>create test-data 2 , 4 , 3 , 1 , 2 , test-data 5 cell-sort</lang>

Fortran

Works with: Silverfrost FTN95

<lang fortran>CALL ISORT@(b, a, n) ! n = number of elements ! a = array to be sorted ! b = array of indices of a. b(1) 'points' to the minimum value etc.</lang>

F#

<lang fsharp>// sorting an array in place let nums = [| 2; 4; 3; 1; 2 |] Array.sortInPlace nums

// create a sorted copy of a list let nums2 = [2; 4; 3; 1; 2] let sorted = List.sort nums2</lang>

Go

<lang go>package main import "fmt" import "sort"

func main() {

 nums := []int {2, 4, 3, 1, 2}
 sort.SortInts(nums)
 fmt.Println(nums)

}</lang>

Groovy

<lang groovy>println ([2,4,0,3,1,2,-12].sort())</lang>

Output:

[-12, 0, 1, 2, 2, 3, 4]

Haskell

Works with: GHCi version 6.6

<lang haskell>nums = [2,4,3,1,2] :: [Int] sorted = List.sort nums</lang>

HicEst

<lang hicest>DIMENSION array(100)

  array = INT( RAN(100) )
  SORT(Vector=array, Sorted=array) </lang>

IDL

<lang idl>result = array[sort(array)]</lang>

Icon and Unicon

Icon and Unicon lists allow mixed type and the built-in function 'sort' will deal with mixed type arrays by sorting by type first then value. Integers sort before, reals, strings, lists, tables, etc. As a result a list of mixed numeric valuess (i.e. integers and reals) will not sort by numeric value, rather the reals will appear after the integers. Sort returns a sorted copy of it's argument. It will also perform some type conversion, such converting an unordered set into an ordered list.

Icon

In the example below, L will remain an unsorted list and S will be sorted. <lang Icon>S := sort(L:= [63, 92, 51, 92, 39, 15, 43, 89, 36, 69]) # will sort a list</lang>

Unicon

The Icon solution works in Unicon.

J

<lang j>/:~</lang> The verb /:~ sorts anything. For example:

<lang j> ] a=: 10 ?@$ 100 NB. random vector 63 92 51 92 39 15 43 89 36 69

  /:~ a

15 36 39 43 51 63 69 89 92 92</lang> Arrays of any rank are treated as lists of component arrays. Thus /:~ sorts not only atoms within a list, but whole lists within a table, tables within a three-axis array, and so on. The level of structure at which sorting occurs may also be specified, so that /:~"1 sorts the atoms within the finest-grained list within the array, regardless of the overall rank of the array.
This code also applies to any data type.

Java

Array

<lang java>import java.util.Arrays;

public class example {

   public static void main(String[] args)
   {
       int[] nums = {2,4,3,1,2};
       Arrays.sort(nums);
   }

}</lang>

List

Works with: Java version 1.5+

<lang java5>import java.util.Arrays; import java.util.Collections; import java.util.List;

public class example {

   public static void main(String[] args)
   {
       List<Integer> nums = Arrays.asList(2,4,3,1,2);
       Collections.sort(nums);
   }

}</lang>

JavaScript

Works with: Firefox version 2.0

JavaScript sorts lexically by default, so "10000" comes before "2". To sort numerically, a custom comparator is used.

<lang javascript>function numberSorter(a, b) {

 return a - b;

} var numbers = [20, 7, 65, 10, 3, 0, 8, -60]; numbers.sort(numberSorter); alert( numbers );</lang>

Io

<lang lua> mums := list(2,4,3,1,2) sorted := nums sort # returns a new sorted array. 'nums' is unchanged nums sortInPlace # sort 'nums' "in-place"</lang>

Lua

<lang lua> t = {4, 5, 2} table.sort(t) print(unpack(t))</lang>

Mathematica

<lang mathematica>numbers = Sort[{2,4,3,1,2}]</lang>

MATLAB

<lang Matlab>a = [4,3,7,-2,9,1]; b = sort(a) % b contains elements of a in ascending order [b,idx] = sort(a) % b contains a(idx)</lang>

MAXScript

Modula-3

Modula-3 provides a generic ArraySort module, as well as an instance of that module for integers called IntArraySort. <lang modula3>MODULE ArraySort EXPORTS Main;

IMPORT IntArraySort;

VAR arr := ARRAY [1..10] OF INTEGER{3, 6, 1, 2, 10, 7, 9, 4, 8, 5};

BEGIN

 IntArraySort.Sort(arr);

END ArraySort.</lang>

MUMPS

<lang MUMPS>SORTARRAY(X,SEP)

;X is the list of items to sort
;X1 is the temporary array
;SEP is the separator string between items in the list X
;Y is the returned list
;This routine uses the inherent sorting of the arrays
NEW I,X1,Y
SET Y=""
FOR I=1:1:$LENGTH(X,SEP) SET X1($PIECE(X,SEP,I))=""
SET I="" FOR  SET I=$O(X1(I)) Q:I=""  SET Y=$SELECT($L(Y)=0:I,1:Y_SEP_I)
KILL I,X1
QUIT Y</lang>

Output:

USER>W $$SORTARRAY^ROSETTA("3,5,1,99,27,16,0,-1",",")
-1,0,1,3,5,16,27,99

Nial

Niue

Library <lang Niue>2 6 1 0 3 8 sort .s 0 1 2 3 6 8 </lang>

Objective-C

Works with: GCC version 4.0.1 (apple)

<lang objc>- (void)example {

   NSArray *nums, *sorted;
   nums = [NSArray arrayWithObjects:
       [NSNumber numberWithInt:2],
       [NSNumber numberWithInt:4],
       [NSNumber numberWithInt:3],
       [NSNumber numberWithInt:1],
       [NSNumber numberWithInt:2],
       nil];
   sorted = [nums sortedArrayUsingSelector:@selector(compare:)];

}</lang>

Objeck

<lang objeck> bundle Default {

 class Sort {
   function : Main(args : System.String[]) ~ Nil {
     nums := Structure.IntVector->New([2,4,3,1,2]);
     nums->Sort();
   }
 }

} </lang>

OCaml

Array

<lang ocaml>let nums = [|2; 4; 3; 1; 2|] Array.sort compare nums</lang>

List

<lang ocaml>let nums = [2; 4; 3; 1; 2] let sorted = List.sort compare nums</lang>

Octave

The variable v can be a vector or a matrix (columns will be sorted).

<lang octave>sortedv = sort(v);</lang>

Oz

<lang oz>declare

 Nums = [2 4 3 1 2]
 Sorted = {List.sort Nums Value.'<'}

in

 {Show Sorted}</lang>

Perl

Works with: Perl version 5.8.6

<lang perl>@nums = (2,4,3,1,2); @sorted = sort {$a <=> $b} @nums;</lang>

Perl 6

Works with: Rakudo version #23 "Lisbon"

If @a contains only numbers:

<lang perl6>my @sorted = sort @a;</lang>

If some elements of @a are strings or are otherwise non-numeric but you want to treat them as numbers:

<lang perl6>my @sorted = sort +*, @a;</lang>

For an in-place sort:

PHP

Works with: PHP version 4.4.4 CLI

PicoLisp

The sort function in PicoLisp returns already by default an ascending list (of any type, not only integers): <lang PicoLisp>(sort (2 4 3 1 2)) -> (1 2 2 3 4)</lang>

PL/I

Works with: IBM PL/I version 7.5

<lang pli>DCL (T(10)) FIXED BIN(31); /* scratch space of length N/2 */

MERGE: PROCEDURE (A,LA,B,LB,C);

  DECLARE (A(*),B(*),C(*)) FIXED BIN(31);
  DECLARE (LA,LB) FIXED BIN(31) NONASGN;
  DECLARE (I,J,K) FIXED BIN(31);
  
  I=1; J=1; K=1;
  DO WHILE ((I <= LA) & (J <= LB));
     IF(A(I) <= B(J)) THEN
        DO; C(K)=A(I); K=K+1; I=I+1; END;
     ELSE
        DO; C(K)=B(J); K=K+1; J=J+1; END;
  END;
  DO WHILE (I <= LA);
     C(K)=A(I); I=I+1; K=K+1;
  END;
  RETURN;

END MERGE;

MERGESORT: PROCEDURE (A,N) RECURSIVE ;

    DECLARE (A(*))               FIXED BINARY(31);
    DECLARE N                    FIXED BINARY(31) NONASGN;
    DECLARE Temp                 FIXED BINARY;
    DECLARE (M,I)                FIXED BINARY;
    DECLARE AMP1(N)              FIXED BINARY(31) BASED(P);
    DECLARE P POINTER;
   IF (N=1) THEN RETURN;
  M = trunc((N+1)/2);
  IF (M>1) THEN CALL MERGESORT(A,M);
  P=ADDR(A(M+1)); 
  IF (N-M > 1) THEN CALL MERGESORT(AMP1,N-M);
  IF A(M) <= AMP1(1) THEN RETURN;
  DO I=1 to M; T(I)=A(I); END;
  CALL MERGE(T,M,AMP1,N-M,A);
  RETURN;

END MERGESORT;</lang>

Pop11

Pop11 library function sorts lists. So we first convert array to list, then sort and finally convert back:

<lang pop11>lvars ar = {2 4 3 1 2};

Convert array to list. destvector leaves its results and on the pop11 stack + an integer saying how many there were

destvector(ar);

conslist uses the items left on the stack plus the integer, to make a list of those items.

lvars ls = conslist();

Sort it

sort(ls) -> ls;

Convert list to array

destlist(ls); consvector() -> ar;</lang>

The above can be abbreviated to more economical, but possibly more opaque, syntax, using pop11 as a functional language:

<lang pop11>lvars ar = {2 4 3 1 2}; consvector(destlist(sort(conslist(destvector(ar))))) -> ar;

print the sorted vector

ar =>

- {1 2 2 3 4}</lang>

(The list created by conslist will be garbage-collected.)

Alternatively, using the datalist function, even more economically:

<lang pop11>lvars ar = {2 4 3 1 2}; consvector(destlist(sort(datalist(ar)))) -> ar;</lang>

or in Forth-like pop11 postfix syntax:

<lang pop11>lvars ar = {2 4 3 1 2}; ar.datalist.sort.destlist.consvector -> ar;</lang>

PowerShell

<lang powershell>34,12,23,56,1,129,4,2,73 | Sort-Object</lang>

PureBasic

<lang PureBasic>Dim numbers(20) For i = 0 To 20

  numbers(i) = Random(1000)

Python

Works with: Python version 2.3

Note: The array nums is sorted in place.

Interpreter: Python 2.4 (and above)

You could also use the built-in sorted() function

<lang python>nums = sorted([2,4,3,1,2])</lang>

R

Raven

Sort list in place:

Ruby

Works with: Ruby version 1.8.4

<lang ruby>nums = [2,4,3,1,2] sorted = nums.sort # returns a new sorted array. 'nums' is unchanged nums.sort! # sort 'nums' "in-place"</lang>

Scala

<lang scala>println(List(5,2,78,2,578,-42).sortWith(_<_)) //--> List(-42, 2, 2, 5, 78, 578) </lang>

Seed7

<lang seed7>var array integer: nums is [] (2, 4, 3, 1, 2);

nums := sort(nums);</lang>

Slate

Smalltalk

<lang smalltalk> #(7 5 2 9 0 -1) asSortedCollection</lang>

Standard ML

Array

Works with: SML/NJ

<lang sml>val nums = Array.fromList [2, 4, 3, 1, 2]; ArrayQSort.sort Int.compare nums;</lang>

List

Works with: SML/NJ

<lang sml>val nums = [2, 4, 3, 1, 2]; val sorted = ListMergeSort.sort (op >) nums;</lang>

Tcl

<lang tcl>set result [lsort -integer $unsorted_list]</lang>

TI-83 BASIC

Store input into L₁, run prgmSORTBTIN, and L₂ will be L₁, only sorted.

:L₁→L₂
:SortA(L₂)

SortA is found via: [LIST] → ENTER. SortD is also available for a descending sort.

Toka

This can be done by using the bubble sort library:

<lang toka>needs bsort arrayname number_elements bsort</lang>

See the Toka entry on Bubble Sort for a full example.

UNIX Shell

<lang bash>nums=(2 4 3 1 2) sorted=($(for i in ${nums[*]}; do echo $i; done | sort -n))</lang> Another way: <lang bash>nums=(2 4 3 1 5) sorted=($(echo "${nums[@]}" | tr ' ' '\12' | sort -n))</lang>

Ursala

using the built in sort operator, -<, with the nleq library function for comparing natural numbers <lang Ursala>#import nat

cast %nL

example = nleq-< <39,47,40,53,14,23,88,52,78,62,41,92,88,66,5,40></lang> output:

<5,14,23,39,40,40,41,47,52,53,62,66,78,88,88,92>