Policy change. Edit privileges will now require email addresses to be confirmed. (Details) --Michael Mol 14:53, 14 March 2012 (UTC)

Sort an integer array

From Rosetta Code
Jump to: navigation, search
Task
Sort an integer array
You are encouraged to solve this task according to the task description, using any language you may know.
Sort an array (or list) of integers in ascending numerical order. Use a sorting facility provided by the language/library if possible.

Contents

[edit] 4D

[edit] English

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

[edit] Français

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

[edit] 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);

[edit] Ada

Works with: GNAT version GPL 2006
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;

[edit] 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
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))

Output: 

         +1         +2         +2         +3         +4

[edit] APL

Works with: APL2
      X←63 92 51 92 39 15 43 89 36 69
      X[⍋X]
15 36 39 43 51 63 69 89 92 92

[edit] AutoHotkey

numbers = 5 4 1 2 3
sort, numbers, N D%A_Space%
Msgbox % numbers

[edit] Befunge

Works with: befungee

Elements of the array are read from standard input, preceded by their quantity. The algorithm uses counting sort and allows numbers between 1 and 60, inclusive. 

v 
> 543** >     :#v_ $&>           :#v_ 1 > :0g >    :#v_ $ 1+: 543** `! #v_ 25*,@
        ^-1p0\0:<    ^-1 p0\+1 g0:&<          ^-1\.:\<
                                        ^                               <

[edit] Bracmat

As a Computer Algebra system, Bracmat transforms expressions to a canonical form. Terms in a sum are sorted and, where possible, added together. So the task is partially solved by expressing the list as a sum of terms. Evaluating the list sorts the list, but also adds like terms. To illustrate, this is what happens when entering our list at the prompt: 

{?} (9.)+(-2.)+(1.)+(2.)+(8.)+(0.)+(1.)+(2.)
{!} (-2.)+(0.)+2*(1.)+2*(2.)+(8.)+(9.)

The use of a computationally inert operator like the dot . is essential: 

{?} (9)+(-2)+(1)+(2)+(8)+(0)+(1)+(2)
{!} 21

To complete the task need to unfold the terms with a numerical factor >1: 

{sort takes a list of space-separated integers}
(sort=
  sum elem sorted n
.   0:?sum
  &   whl
    ' (!arg:%?elem ?arg&(!elem.)+!sum:?sum)
  & :?sorted
  &   whl
    ' ( !sum:?n*(?elem.)+?sum
      &   whl
        ' ( !n+-1:~<0:?n
          & !sorted !elem:?sorted
          )
      )
  & !sorted);
 
  out$sort$(9 -2 1 2 8 0 1 2);

Output: 

-2 0 1 1 2 2 8 9

This solution becomes very ineffective for long lists. To add a single term to an already sorted sum of N terms requires on average N/2 steps. It is much more efficient to merge two already sorted sums of about equal length. Also, adding elements to the end of the list 'sorted' is costly. Better is to prepend elements to a list, which will have inverted sorting order, and to invert this list in an extra loop.

[edit] C

#include <stdlib.h>  /* qsort() */
#include <stdio.h>   /* printf() */
 
int intcmp(const void *aa, const void *bb)
{
    const int *a = aa, *b = bb;
    return (*a < *b) ? -1 : (*a > *b);
}
 
int main()
{
    int nums[5] = {2,4,3,1,2};
    qsort(nums, 5, sizeof(int), intcmp);
    printf("result: %d %d %d %d %d\n",
      nums[0], nums[1], nums[2], nums[3], nums[4]);
    return 0;
}

Caution: An older version of intcmp() did return *a - *b. This is only correct when the subtraction does not overflow. Suppose that *a = 2000000000 and *b = -2000000000 on a machine with 32-bit int. The subtraction *a - *b would overflow to -294967296, and intcmp() would believe *a < *b, but the correct answer is *a > *b.

[edit] C++

Works with: g++ version 4.0.1

[edit] Simple Array

#include <algorithm>
 
int main()
{
    int nums[] = {2,4,3,1,2};
    std::sort(nums, nums+5);
    return 0;
}

[edit] std::vector

#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());
    return 0;
}

[edit] std::list

#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();
    return 0;
}

[edit] C#

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);
    }
}

[edit] 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. 

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}

[edit] Clojure

(sort [5 4 3 2 1]) ; sort can also take a comparator function
(1 2 3 4 5)

[edit] 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: 

CL-USER> (sort #(9 -2 1 2 8 0 1 2) #'<)
#(-2 0 1 1 2 2 8 9)

[edit] D

import std.stdio, std.algorithm;
 
void main() {
    auto data = [2, 4, 3, 1, 2];
    data.sort(); // in-place
    assert(data == [1, 2, 2, 3, 4]);
}

[edit] Delphi

uses Types, Generics.Collections;
 
var
  a: TIntegerDynArray;
begin
  a := TIntegerDynArray.Create(5, 4, 3, 2, 1);
  TArray.Sort<Integer>(a);

[edit] E

[2,4,3,1,2].sort()

[edit] Erlang

List = [2, 4, 3, 1, 2].
SortedList = lists:sort(List).

[edit] Euphoria

include sort.e
print(1,sort({20, 7, 65, 10, 3, 0, 8, -60}))

[edit] Factor

{ 1 4 9 2 3 0 5 } natural-sort .

[edit] Fantom

The List collection contains a sort method which uses the usual comparison method for the data in the list; the sort is done 'in place'. 

fansh> a := [5, 1, 4, 2, 3]
[5, 1, 4, 2, 3]
fansh> a.sort
[1, 2, 3, 4, 5]
fansh> a
[1, 2, 3, 4, 5]

[edit] Forth

Works with: Win32Forth version 4.2
create test-data 2 , 4 , 3 , 1 , 2 ,
test-data 5 cell-sort

[edit] Fortran

Works with: Silverfrost FTN95
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.

[edit] F#

// 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

[edit] GAP

a := [ 8, 2, 5, 9, 1, 3, 6, 7, 4 ];
# Make a copy (with "b := a;", b and a would point to the same list)
b := ShallowCopy(a);
 
# Sort in place
Sort(a);
a;
# [ 1, 2, 3, 4, 5, 6, 7, 8, 9 ]
 
# Sort without changing the argument
SortedList(b);
# [ 1, 2, 3, 4, 5, 6, 7, 8, 9 ]
b;
# [ 8, 2, 5, 9, 1, 3, 6, 7, 4 ]

[edit] Go

package main
import "fmt"
import "sort"
 
func main() {
  nums := []int {2, 4, 3, 1, 2}
  sort.Ints(nums)
  fmt.Println(nums)
}

[edit] Golfscript

[2 4 3 1 2]$

[edit] Groovy

println ([2,4,0,3,1,2,-12].sort())

Output: 

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

[edit] Haskell

Works with: GHCi version 6.6
nums = [2,4,3,1,2] :: [Int]
sorted = List.sort nums

[edit] HicEst

DIMENSION array(100)
 
   array = INT( RAN(100) )
   SORT(Vector=array, Sorted=array)

[edit] IDL

result = array[sort(array)]

[edit] 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.

In the example below, L will remain an unsorted list and S will be sorted. 

S := sort(L:= [63, 92, 51, 92, 39, 15, 43, 89, 36, 69])  # will sort a list

[edit] Io

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

[edit] Inform 7

let L be {5, 4, 7, 1, 18};
sort L;

[edit] J

/:~

The verb /:~ sorts anything. For example: 

   ] 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

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.

[edit] Java

[edit] Array

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

[edit] List

Works with: Java version 1.5+
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);
    }
}

[edit] 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. 

function int_arr(a, b) {
  return a - b;
}
var numbers = [20, 7, 65, 10, 3, 0, 8, -60];
numbers.sort(int_arr);
document.write(numbers);

[edit] K

  num: -10?10              / Integers from 0 to 9 in random order
5 9 4 2 0 3 6 1 8 7
 
  srt: {x@<x}              / Generalized sort ascending
  srt num
0 1 2 3 4 5 6 7 8 9

[edit] Liberty BASIC

LB has an array-sort command. Parameters are arrayname, start term, finish term. 

N =20
dim IntArray( N)
 
print "Original order"
for i =1 to N
    t =int( 1000 *rnd( 1))
    IntArray( i) =t
    print t
next i
 
sort IntArray(), 1, N
 
print "Sorted oprder"
for i =1 to N
    print IntArray( i)
next i

[edit] Lua

t = {4, 5, 2}
table.sort(t)
print(unpack(t))

[edit] Mathematica

numbers = Sort[{2,4,3,1,2}]

[edit] 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)

[edit] MAXScript

arr = #(5, 4, 3, 2, 1)
arr = sort arr

[edit] Mercury

:- module sort_int_list.
:- interface.
:- import_module io.
 
:- pred main(io::di, uo::uo) is det.
 
:- implementation.
:- import_module list.
 
main(!IO) :-
  Nums = [2, 4, 0, 3, 1, 2],
  list.sort(Nums, Sorted),
  io.write(Sorted, !IO),
  io.nl(!IO).


[edit] Modula-3

Modula-3 provides a generic ArraySort module, as well as an instance of that module for integers called IntArraySort. 

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.

[edit] 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
Output:
USER>W $$SORTARRAY^ROSETTA("3,5,1,99,27,16,0,-1",",")
-1,0,1,3,5,16,27,99

[edit] NetRexx

/* NetRexx */
options replace format comments java crossref savelog symbols binary
 
ia = int[]
ia = [ 2, 4, 3, 1, 2, -1, 0, -2 ]
 
display(ia)
Arrays.sort(ia)
display(ia)
 
-- Display results
method display(in = int[]) public static
 
  sorted = Rexx('')
 
  loop ix = 0 for in.length
    sorted = sorted || Rexx(in[ix]).right(4)
    end ix
 
  say sorted.strip('t')
 
  return

Output 

   2   4   3   1   2  -1   0  -2 
  -2  -1   0   1   2   2   3   4

NetRexx reimplementations of the Rexx samples from below: 

/* NetRexx */
options replace format comments java crossref savelog symbols
 
/*REXX program to sort an integer array.*/
 
numeric digits 20    /*handle larger numbers.*/
a = ''
a[ 1]=               1
a[ 2]=               0
a[ 3]=              -1
a[ 4]=               0
a[ 5]=               5
a[ 6]=               0
a[ 7]=             -61
a[ 8]=               0
a[ 9]=            1385
a[10]=               0
a[11]=          -50521
a[12]=               0
a[13]=         2702765
a[14]=               0
a[15]=      -199360981
a[16]=               0
a[17]=     19391512145
a[18]=               0
a[19]=  -2404879675441
a[20]=               0
a[21]= 370371188237525
 
size = 21                          /*we have a list of 21 Euler numbers.*/
tell('un-sorted', a, size)
a[0] = size
esort(a, 1)
tell('   sorted', a, size)
 
return
 
/*----------------------------------ESORT subroutine--------------------*/
method esort(a, size) public static
--esort: procedure expose a.;
 
  h = a[0]
 
  loop while h > 1
    h = h % 2
    loop i = 1 for a[0] - h
      j = i
      k = h + i
      loop while a[k] < a[j]
        t    = a[j]
        a[j] = a[k]
        a[k] = t
        if h >= j then leave
        j = j - h
        k = k - h
        end
      end i
    end
 
return
 
/*----------------------------------TELL subroutine---------------------*/
method tell(arg, a, size) public static
--tell:
 
  say arg.center(40, '-')
  loop j = 1 for size
    say arg 'array element' j.right(size.length)'='a[j].right(25)
    end j
  say
 
  return

Output 

---------------un-sorted----------------
un-sorted array element  1=                        1
un-sorted array element  2=                        0
un-sorted array element  3=                       -1
un-sorted array element  4=                        0
un-sorted array element  5=                        5
un-sorted array element  6=                        0
un-sorted array element  7=                      -61
un-sorted array element  8=                        0
un-sorted array element  9=                     1385
un-sorted array element 10=                        0
un-sorted array element 11=                   -50521
un-sorted array element 12=                        0
un-sorted array element 13=                  2702765
un-sorted array element 14=                        0
un-sorted array element 15=               -199360981
un-sorted array element 16=                        0
un-sorted array element 17=              19391512145
un-sorted array element 18=                        0
un-sorted array element 19=           -2404879675441
un-sorted array element 20=                        0
un-sorted array element 21=          370371188237525

---------------   sorted----------------
   sorted array element  1=           -2404879675441
   sorted array element  2=               -199360981
   sorted array element  3=                   -50521
   sorted array element  4=                      -61
   sorted array element  5=                       -1
   sorted array element  6=                        0
   sorted array element  7=                        0
   sorted array element  8=                        0
   sorted array element  9=                        0
   sorted array element 10=                        0
   sorted array element 11=                        0
   sorted array element 12=                        0
   sorted array element 13=                        0
   sorted array element 14=                        0
   sorted array element 15=                        0
   sorted array element 16=                        1
   sorted array element 17=                        5
   sorted array element 18=                     1385
   sorted array element 19=                  2702765
   sorted array element 20=              19391512145
   sorted array element 21=          370371188237525

/* NetRexx */
options replace format comments java crossref savelog symbols
 
/*REXX program to sort an interesting integer list.*/
 
bell = '1 1 2 5 15 52 203 877 4140 21147 115975'      /*some Bell numbers.*/
bern = '1 -1 1 0 -1 0 1 0 -1 0 5 0 -691 0 7 0 -3617'  /*some Bernoulli num*/
perrin = '3 0 2 3 2 5 5 7 10 12 17 22 29 39 51 68 90' /*some Perrin nums. */
list = bell bern perrin                               /*combine the three.*/
 
size = list.words
 
a = 0
loop j = 1 for size
  a[j] = list.word(j)
  end j
 
say '  as is='list
a[0] = size
esort(a, size)
bList = ''
 
loop j = 1 for size
  bList = bList a[j]
  end j
 
blist = bList.strip
say ' sorted='bList
 
return
 
/*----------------------------------ESORT subroutine--------------------*/
method esort(a, size) public static
--esort: procedure expose a.;
 
  h = a[0]
 
  loop while h > 1
    h = h % 2
    loop i = 1 for a[0] - h
      j = i
      k = h + i
      loop while a[k] < a[j]
        t    = a[j]
        a[j] = a[k]
        a[k] = t
        if h >= j then leave
        j = j - h
        k = k - h
        end
      end i
    end
 
return

Output 

  as is=1 1 2 5 15 52 203 877 4140 21147 115975 1 -1 1 0 -1 0 1 0 -1 0 5 0 -691 0 7 0 -3617 3 0 2 3 2 5 5 7 10 12 17 22 29 39 51 68 90
 sorted=-3617 -691 -1 -1 -1 0 0 0 0 0 0 0 0 1 1 1 1 1 2 2 2 3 3 5 5 5 5 7 7 10 12 15 17 22 29 39 51 52 68 90 203 877 4140 21147 115975

[edit] Nial

sort >= 9 6 8 7 1 10
= 10 9 8 7 6 1

[edit] Niue

Library 

2 6 1 0 3 8 sort .s
0 1 2 3 6 8

[edit] Objective-C

Works with: GCC version 4.0.1 (apple)
- (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:)];
}

[edit] Objeck

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

[edit] OCaml

[edit] Array

let nums = [|2; 4; 3; 1; 2|]
Array.sort compare nums

[edit] List

let nums = [2; 4; 3; 1; 2]
let sorted = List.sort compare nums

[edit] Octave

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

sortedv = sort(v);

[edit] Oz

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

[edit] PARI/GP

vecsort(v)

[edit] Perl

Works with: Perl version 5.8.6
@nums = (2,4,3,1,2);
@sorted = sort {$a <=> $b} @nums;

[edit] Perl 6

Works with: Rakudo version #23 "Lisbon"

If @a contains only numbers: 

my @sorted = sort @a;

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

my @sorted = sort +*, @a;

For an in-place sort: 

@a .= sort;

[edit] PHP

Works with: PHP version 4.4.4 CLI
<?php
$nums = array(2,4,3,1,2);
sort($nums);
?>

[edit] PicoLisp

The sort function in PicoLisp returns already by default an ascending list (of any type, not only integers): 

(sort (2 4 3 1 2))
-> (1 2 2 3 4)

[edit] PL/I

Works with: IBM PL/I version 7.5
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;

[edit] Pop11

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

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;

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

lvars ar = {2 4 3 1 2};
consvector(destlist(sort(conslist(destvector(ar))))) -> ar;
;;; print the sorted vector:
ar =>
** {1 2 2 3 4}

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

Alternatively, using the datalist function, even more economically: 

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


or in Forth-like pop11 postfix syntax: 

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

[edit] PowerBASIC

PowerBASIC has several options available for sorting. At its simplest, an array (of any type) is sorted using ARRAY SORT: 

ARRAY SORT x()

Options are available to limit sorting to only part of the array, collate string arrays, sort multiple arrays together, etc. (Details here.)

[edit] PowerShell

34,12,23,56,1,129,4,2,73 | Sort-Object

[edit] Prolog

 ?- msort([10,5,13,3, 85,3,1], L).
L = [1,3,3,5,10,13,85].

Note that sort/2 remove duplicates.

[edit] PureBasic

Dim numbers(20)
For i = 0 To 20
   numbers(i) = Random(1000)
Next
 
SortArray(numbers(), #PB_Sort_Ascending)

[edit] Python

Works with: Python version 2.3
nums = [2,4,3,1,2]
nums.sort()

Note: The array nums is sorted in place.

Interpreter: Python 2.4 (and above)

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

nums = sorted([2,4,3,1,2])

[edit] R

nums <- c(2,4,3,1,2)
sorted <- sort(nums)

[edit] Raven

Sort list in place: 

[ 2 4 3 1 2 ] sort

[edit] REBOL

sort [2 4 3 1 2]

[edit] REXX

This version creates an array with 20 random integers, then sorts it. 

/*REXX program to sort an integer array.*/
                           numeric digits 20    /*handle larger numbers.*/
 a.1=               1
 a.2=               0
 a.3=              -1
 a.4=               0
 a.5=               5
 a.6=               0
 a.7=             -61
 a.8=               0
 a.9=            1385
a.10=               0
a.11=          -50521
a.12=               0
a.13=         2702765
a.14=               0
a.15=      -199360981
a.16=               0
a.17=     19391512145
a.18=               0
a.19=  -2404879675441
a.20=               0
a.21= 370371188237525
 
size=21                            /*we have a list of 21 Euler numbers.*/
call tell 'un-sorted'
a.0=size
call esort 1,size
call tell '   sorted'
exit
/*----------------------------------ESORT subroutine--------------------*/
esort: procedure expose a.; h=a.0
  do while h>1; h=h%2
    do i=1 for a.0-h; j=i; k=h+i
      do while a.k<a.j
      t=a.j; a.j=a.k; a.k=t; if h>=j then leave; j=j-h; k=k-h
      end
    end
  end
return
/*----------------------------------TELL subroutine---------------------*/
tell: say center(arg(1),40,'-')
  do j=1 for size
  say arg(1) 'array element' right(j,length(size))'='right(a.j,20)
  end
say
return

output 

---------------un-sorted----------------
un-sorted array element  1=                   1
un-sorted array element  2=                   0
un-sorted array element  3=                  -1
un-sorted array element  4=                   0
un-sorted array element  5=                   5
un-sorted array element  6=                   0
un-sorted array element  7=                 -61
un-sorted array element  8=                   0
un-sorted array element  9=                1385
un-sorted array element 10=                   0
un-sorted array element 11=              -50521
un-sorted array element 12=                   0
un-sorted array element 13=             2702765
un-sorted array element 14=                   0
un-sorted array element 15=          -199360981
un-sorted array element 16=                   0
un-sorted array element 17=         19391512145
un-sorted array element 18=                   0
un-sorted array element 19=      -2404879675441
un-sorted array element 20=                   0
un-sorted array element 21=     370371188237525

---------------   sorted----------------
   sorted array element  1=      -2404879675441
   sorted array element  2=          -199360981
   sorted array element  3=              -50521
   sorted array element  4=                 -61
   sorted array element  5=                  -1
   sorted array element  6=                   0
   sorted array element  7=                   0
   sorted array element  8=                   0
   sorted array element  9=                   0
   sorted array element 10=                   0
   sorted array element 11=                   0
   sorted array element 12=                   0
   sorted array element 13=                   0
   sorted array element 14=                   0
   sorted array element 15=                   0
   sorted array element 16=                   1
   sorted array element 17=                   5
   sorted array element 18=                1385
   sorted array element 19=             2702765
   sorted array element 20=         19391512145
   sorted array element 21=     370371188237525

This version creates a list with a bunch of interesting integers, then sorts it.
Because it so much more efficient to sort an array, an array is built from the list, sorted, than the list is re-constituted. 

/*REXX program to sort an interesting integer list.*/
 
bell='1 1 2 5 15 52 203 877 4140 21147 115975'      /*some Bell numbers.*/
bern='1 -1 1 0 -1 0 1 0 -1 0 5 0 -691 0 7 0 -3617'  /*some Bernoulli num*/
perrin='3 0 2 3 2 5 5 7 10 12 17 22 29 39 51 68 90' /*some Perrin nums. */
list=bell bern perrin                               /*combine the three.*/
 
size=words(list)
                     do j=1 for size
                     a.j=word(list,j)
                     end
say '  as is='list
a.0=size
call esort 1,size
bList=
                     do j=1 for size
                     bList=bList a.j
                     end
 
blist=strip(bList)
say 'sorted='bList
exit
/*----------------------------------ESORT subroutine--------------------*/
esort:procedure expose a.;h=a.0
  do while h>1;h=h%2
    do i=1 for a.0-h;j=i; k=h+i
      do while a.k<a.j;_=a.j;a.j=a.k;a.k=_;if h>=j then leave;j=j-h;k=k-h;end
    end
  end
return

Output: 

  as is=1 1 2 5 15 52 203 877 4140 21147 115975 1 -1 1 0 -1 0 1 0 -1 0 5 0 -691 0 7 0 -3617 3 0 2 3 2 5 5 7 10 12 17 22 29 39 51 68 90
sorted=-3617 -691 -1 -1 -1 0 0 0 0 0 0 0 0 1 1 1 1 1 2 2 2 3 3 5 5 5 5 7 7 10 12 15 17 22 29 39 51 52 68 90 203 877 4140 21147 115975

[edit] Ruby

Works with: Ruby version 1.8.4
nums = [2,4,3,1,2]
sorted = nums.sort  # returns a new sorted array.  'nums' is unchanged
nums.sort!  # sort 'nums' "in-place"

[edit] Scala

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

[edit] Scheme

Works with: Guile

Same as Common Lisp 

(sort #(9 -2 1 2 8 0 1 2) #'<)

[edit] Seed7

var array integer: nums is [] (2, 4, 3, 1, 2);
 
nums := sort(nums);

[edit] Slate

 #(7 5 2 9 0 -1) sort

[edit] Smalltalk

 #(7 5 2 9 0 -1) asSortedCollection

[edit] Standard ML

The Standard ML Basis library does not have any sorting facilities. But each implementation of Standard ML has its own.

[edit] Array

Works with: SML/NJ
- val nums = Array.fromList [2, 4, 3, 1, 2];
val nums = [|2,4,3,1,2|] : int array
- ArrayQSort.sort Int.compare nums;
val it = () : unit
- nums;
val it = [|1,2,2,3,4|] : int array
Works with: Moscow ML
- load "Arraysort";
> val it = () : unit
- load "Int";
> val it = () : unit
- val nums = Array.fromList [2, 4, 3, 1, 2];
> val nums = <array> : int array
- Arraysort.sort Int.compare nums;
> val it = () : unit
- Array.foldr op:: [] nums;
> val it = [1, 2, 2, 3, 4] : int list

[edit] List

Works with: SML/NJ
- val nums = [2, 4, 3, 1, 2];
val nums = [2,4,3,1,2] : int list
- val sorted = ListMergeSort.sort op> nums;
val sorted = [1,2,2,3,4] : int list
Works with: Moscow ML
- load "Listsort";
> val it = () : unit
- load "Int";
> val it = () : unit
- val nums = [2, 4, 3, 1, 2];
> val nums = [2, 4, 3, 1, 2] : int list
- val sorted = Listsort.sort Int.compare nums;
> val sorted = [1, 2, 2, 3, 4] : int list

[edit] Tcl

set result [lsort -integer $unsorted_list]

[edit] TI-83 BASIC

Store input into L1, run prgmSORTBTIN, and L2 will be L1, only sorted. 

:L1→L2
:SortA(L2)

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

[edit] Toka

This can be done by using the bubble sort library: 

needs bsort
arrayname number_elements bsort

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

[edit] UNIX Shell

Each shell parameter separates the integers using the default IFS whitespace (space, tab, newline). 

nums="2 4 3 1 5"
sorted=`printf "%s\n" $nums | sort -n`
echo $sorted  # prints 1 2 3 4 5

Alternate solution: sorted=`for i in $nums; do echo $i; done | sort -n`

Some shells have real arrays. You still need IFS to split the string from sort -n to an array.

Works with: pdksh version 5.2.14
set -A nums 2 4 3 1 5
set -A sorted $(printf "%s\n" ${nums[*]} | sort -n)
echo ${sorted[*]}  # prints 1 2 3 4 5

Users of bash, ksh93 and mksh can probably use the nums=(2 4 3 1 2) syntax.

[edit] Ursala

using the built in sort operator, -<, with the nleq library function for comparing natural numbers 

#import nat
 
#cast %nL
 
example = nleq-< <39,47,40,53,14,23,88,52,78,62,41,92,88,66,5,40>

output: 

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

[edit] XPL0

include c:\cxpl\codes;          \intrinsic 'code' declarations
 
proc    SSort(A, N);            \Shell sort array in ascending order
int     A;                      \address of array
int     N;                      \number of elements in array (size)
int     I, J, Gap, JG, T;
[Gap:= N>>1;
while Gap > 0 do
        [for I:= Gap to N-1 do
                [J:= I - Gap;
                loop    [JG:= J + Gap;
                        if A(J) <= A(JG) then quit;
                        T:= A(J);   A(J):= A(JG);   A(JG):= T;  \swap elements
                        J:= J - Gap;
                        if J < 0 then quit;
                        ];
                ];
        Gap:= Gap>>1;
        ];
];      \SSort
 
int A, I;
[A:= [3, 1, 4, 1, 5, 9, 2, 6, 5, 4];
SSort(A, 10);
for I:= 0 to 10-1 do [IntOut(0, A(I));  ChOut(0, ^ )];
CrLf(0);
]

Output: 

1 1 2 3 4 4 5 5 6 9

[edit] Yorick

In Yorick, sort returns an index list into the array that will put it in sorted order. 

 
nums = [2,4,3,1,2];
nums = nums(sort(nums));
 
Retrieved from "http://rosettacode.org/mw/index.php?title=Sort_an_integer_array&oldid=136655"
Personal tools
Namespaces
Variants
Actions
Community/News
Browse wiki
Misc
Toolbox