Sort a list

**MuPAD® notebooks are not recommended. Use MATLAB® live scripts instead.**

**MATLAB live scripts support most MuPAD functionality, though there are some differences. For more information, see Convert MuPAD Notebooks to MATLAB Live Scripts.**

`sort(``list`

, <`f`

>)

`sort(list)`

returns a sorted copy of the list.

`sort`

sorts the list in ascending order.

If you do not specify a procedure `f`

, the `sort`

command
uses the following rules for sorting the lists:

The command sorts a list of real numbers (

`Type::Real`

) numerically.The command sorts a list of character strings alphabetically.

The command sorts an outer list containing inner lists with numeric first entries by these numeric first entries. See Example 4.

In all other cases, the command sorts a list according to the internal order:

`sort(list)`

is equivalent to`sort(list, sysorder)`

. All MuPAD^{®}sessions use the same internal order. Between different versions of MuPAD, internal order might change.

When you sort strings, uppercase letters have a preference over
lowercase letters. For example, `Z`

appears before `abc`

.

You can specify a procedure `f`

to define the
sorting criteria. `sort`

calls the procedure `f`

for
every pair of the entries of the list. `f`

must return
a Boolean expression that the `bool`

command can evaluate to `TRUE`

or `FALSE`

.
If for the pair of entries the procedure `f(x, y)`

returns `TRUE`

, the
sorted list displays `x`

to the left of `y`

.
Otherwise, `x`

appears to the right of `y`

.
The entries of the sorted list `L := sort(list, f)`

satisfy `bool`

```
(f(L[i],
L[j])) = TRUE
```

for `i < j`

.

If two entries of a list are equal by the sorting criteria `f`

,
the `sort`

command can swap these entries. For example,
if you sort polynomials by their degrees, the `sort`

command
can return the polynomials with the same degree in the order different
from their order in the input.

`sort`

can be overloaded by kernel domains.
For example, use the function `DOM_SET::sort`

to
sort sets. See Example 3

The average runtime to sort a list containing *n* entries
is *O*(*n* *log*(*n*)).

The `sort`

command sorts real numbers (type `Type::Real`

) numerically:

sort([4, -1, 2/3, 0.5])

The `sort`

command sorts strings alphabetically:

sort(["chip", "alpha", "Zip"])

If a list contains other types of objects the `sort`

command
sorts a list according to the internal order. The command also applies
internal order to sort the lists with mixed types of entries:

sort([4, -1, 2/3, 0.5, "alpha"])

sort([4, -1, 2/3, 0.5, I])

Define your own criteria to sort a list. For example, sort the entries by their absolute values:

sort([-2, 1, -3, 4], (x, y) -> abs(x) < abs(y))

When sorting sets, the `sort`

command returns
a list as a result:

sort({3, 12, 5, 30, 6, 43})

The sorted set is equivalent to the corresponding sorted list:

bool(sort({3, 12, 5, 30, 6, 43}) = sort([3, 12, 5, 30, 6, 43]))

To sort other data types, implement a `sort`

-slot
for them:

unprotect(DOM_INT): DOM_INT::sort := proc(n) local str, i; begin str := expr2text(n); text2expr(_concat(op(sort([str[i] $ i = 1..length(str)])))) end: sort(1703936)

delete DOM_INT::sort: protect(DOM_INT):

If the list contains lists as entries, and all the inner lists
start with numbers, the `sort`

command uses these
numbers to sort the outer list:

sort([[10 - i, i*x^i] $ i = 1..9])

Compare the sorted list with the internal order of its entries:

sort([[10 - i, i*x^i] $ i = 1..9], sysorder)

List.

`list`

Was this topic helpful?