Documentation

This is machine translation

Translated by
Mouse over text to see original. Click the button below to return to the English verison of the page.

sort

Sort array elements

Syntax

• ``B = sort(A)``
example
• ``B = sort(A,dim)``
example
• ``B = sort(___,direction)``
example
• ``````[B,I] = sort(___)``````
example

Description

example

````B = sort(A)` sorts the elements of `A` in ascending order along the first array dimension whose size does not equal 1.If `A` is a vector, then `sort(A)` sorts the vector elements.If `A` is a matrix, then `sort(A)` treats the columns of `A` as vectors and sorts each column.If `A` is a multidimensional array, then `sort(A)` operates along the first array dimension whose size does not equal 1, treating the elements as vectors.```

example

````B = sort(A,dim)` returns the sorted elements of `A` along dimension `dim`. For example, if `A` is a matrix, then `sort(A,2)` sorts the elements in each row.```

example

````B = sort(___,direction)` returns sorted elements of `A` in the order specified by `direction` using any of the previous syntaxes. `'ascend'`, indicates ascending order (default) and `'descend'` indicates descending order.```

example

``````[B,I] = sort(___)``` also returns a collection of index vectors for any of the previous syntaxes. `I` is the same size as `A` and describes the arrangement of the elements of `A` into `B` along the sorted dimension. For example, if `A` is a numeric vector, `B = A(I)`.```

Examples

collapse all

Create a row vector and sort its elements in ascending order.

```A = [9 0 -7 5 3 8 -10 4 2]; B = sort(A) ```
```B = -10 -7 0 2 3 4 5 8 9 ```

Create a matrix and sort each of its rows in ascending order.

```A = [3 6 5; 7 -2 4; 1 0 -9] ```
```A = 3 6 5 7 -2 4 1 0 -9 ```
```B = sort(A,2) ```
```B = 3 5 6 -2 4 7 -9 0 1 ```

Create a matrix and sort its columns in descending order.

```A = [10 -12 4 8; 6 -9 8 0; 2 3 11 -2; 1 1 9 3] ```
```A = 10 -12 4 8 6 -9 8 0 2 3 11 -2 1 1 9 3 ```
```B = sort(A,'descend') ```
```B = 10 3 11 8 6 1 9 3 2 -9 8 0 1 -12 4 -2 ```

Starting in R2016b, you can create string arrays using the `string` function, and sort them using the `sort` function. Sort strings in each column of a string array according to Unicode® dictionary order.

```A = string({'Smith','Burns';... 'Jones','Matthews';... 'Peterson','Adams'}); B = sort(A) ```
```B = 3×2 string array "Jones" "Adams" "Peterson" "Burns" "Smith" "Matthews" ```

Sort the strings in each row.

```B = sort(A,2) ```
```B = 3×2 string array "Burns" "Smith" "Jones" "Matthews" "Adams" "Peterson" ```

Text processing functions (such as `strfind` and `regexp`) accept string arrays as inputs, but other functions (for example, `addpath`) do not.

Create an array of `datetime` values and sort them in ascending order, that is, from the earliest to the latest calendar date.

```ds = {'2012-12-22';'2063-04-05';'1992-01-12'}; A = datetime(ds,'Format','yyyy-MM-dd') ```
```A = 3×1 datetime array 2012-12-22 2063-04-05 1992-01-12 ```
```[B,I] = sort(A) ```
```B = 3×1 datetime array 1992-01-12 2012-12-22 2063-04-05 I = 3 1 2 ```

`B` lists the sorted dates and `I` contains the corresponding indices of `A`.

Access the sorted elements from the original array directly by using the index array `I`.

```A(I) ```
```ans = 3×1 datetime array 1992-01-12 2012-12-22 2063-04-05 ```

Create a 2-by-2-by-2 array and sort its elements in ascending order along the third dimension.

```A(:,:,1) = [2 3; 1 6]; A(:,:,2) = [-1 9; 0 12]; A ```
```A(:,:,1) = 2 3 1 6 A(:,:,2) = -1 9 0 12 ```
```B = sort(A,3) ```
```B(:,:,1) = -1 3 0 6 B(:,:,2) = 2 9 1 12 ```

Use `A(:)`, the column representation of `A`, to sort all of the elements of `A`.

```B = sort(A(:)) ```
```B = -1 0 1 2 3 6 9 12 ```

Input Arguments

collapse all

Input array, specified as a vector, matrix, or multidimensional array.

• If `A` is a scalar, then `sort(A)` returns `A`.

• If `A` is an empty 0-by-0 matrix, then `sort(A)` returns an empty 0-by-0 matrix.

• If `A` contains `NaN` values or undefined `categorical` or `datetime` elements, then `sort(A)` places them on the high end of the sort (as if they were large numbers).

• If `A` is complex, then `sort(A)` sorts the elements by magnitude. If more than one element has equal magnitude, the elements are sorted by phase angle on the interval [−π, π].

• If `A` is a character array or a string array, then `sort(A)` sorts the elements according to the code order for the UTF-16 character encoding scheme. The sort is case-sensitive.

• `sort` reorders strings within a string array, but does not reorder characters within the strings.

Data Types: `double` | `single` | `int8` | `int16` | `int32` | `int64` | `uint8` | `uint16` | `uint32` | `uint64` | `logical` | `char` | `string` | `cell` | `categorical` | `datetime` | `duration`
Complex Number Support: Yes

Dimension to operate along, specified as a positive integer scalar. If no value is specified, the default is the first array dimension whose size does not equal 1.

Consider a two-dimensional input array, `A`:

• `sort(A,1)` sorts the elements in the columns of `A`.

• `sort(A,2)` sorts the elements in the rows of `A`.

`sort` returns `A` if `dim` is greater than `ndims(A)`. If `A` is a cell array, then `dim` is not supported.

Sorting direction, specified as `'ascend'` or `'descend'`. If `A` is a cell array, then `direction` is not supported.

Example: `sort(A,2,'descend')` sorts the rows of `A` in descending order.

Data Types: `char`

Output Arguments

collapse all

Sorted array, returned as a vector, matrix, or multidimensional array the same size and type as `A`. The ordering of the elements in `B` preserves the order of any equal elements in `A`.

Sort index, returned as a vector, matrix, or multidimensional array the same size as `A`. The index vectors are oriented along the same dimension that `sort` operates on. For example, if `A` is a 2-by-3 matrix, then ```[B,I] = sort(A,2)``` sorts the elements in each row of `A`. `I` is a collection of 1-by-3 row index vectors describing the rearrangement. If you do not specify `dim`, then ```[B,I] = sort(A)``` sorts the columns of `A`, and `I` is a collection of 2-by-1 column index vectors.

collapse all

Sort Order for Character and String Arrays

MATLAB® stores characters as Unicode® using the UTF-16 character encoding scheme. Character and string arrays are sorted according to the UTF-16 code point order. For the characters that are also the ASCII characters, this order means that uppercase letters come before lowercase letters. Digits and some punctuation also come before letters.

Tips

• The `sortrows` function provides additional flexibility for subsorting over multiple columns of nonvector input arrays.

• The `sort` function and the relational operators use different orderings for complex numbers. For more information, see Relational Operations.