# Documentation

### This is machine translation

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

Note: This page has been translated by MathWorks. Please click here
To view all translated materals including this page, select Japan from the country navigator on the bottom of this page.

# issorted

Determine if array is sorted

## Syntax

``TF = issorted(A)``
``TF = issorted(A,dim)``
``TF = issorted(___,direction)``
``TF = issorted(___,Name,Value)``
``TF = issorted(A,'rows')``

## Description

example

````TF = issorted(A)` returns the logical scalar 1 (`true`) when the elements of `A` are listed in ascending order and 0 (`false`) otherwise.If `A` is a vector, then `issorted` returns 1 when the vector elements are in ascending order.If `A` is a matrix, then `issorted` returns 1 when each column of `A` is in ascending order.If `A` is a multidimensional array, then `issorted` returns 1 when `A` is in ascending order along the first dimension whose size does not equal 1.If `A` is a timetable, then `issorted` returns 1 when its row time vector is in ascending order. To check the ordering of row times or variables of a timetable with additional options, use the `issortedrows` function.```

example

````TF = issorted(A,dim)` returns 1 when `A` is sorted along dimension `dim`. For example, if `A` is a matrix, then `issorted(A,2)` returns 1 when each row of `A` is in ascending order.```

example

````TF = issorted(___,direction)` returns 1 when `A` is sorted in the order specified by `direction` for any of the previous syntaxes. For example, `issorted(A,'monotonic')` returns 1 if the elements of `A` are ascending or descending.```

example

````TF = issorted(___,Name,Value)` specifies additional parameters for checking sort order. For example, `issorted(A,'ComparisonMethod','abs')` checks if `A` is sorted by magnitude.```
````TF = issorted(A,'rows')` returns 1 when the elements of the first column of a matrix are sorted. If the first column contains repeated elements, then `issorted` looks at the ordering of the second column to determine `TF`. In general, `issorted` looks to the column immediately to the right to determine `TF` when the current and previous columns have repeated elements.If `A` is a timetable, then `issortedrows` checks if the row time vector is in ascending order.This syntax is not supported for a matrix of character vectors. NoteThis syntax is not recommended. Use `issortedrows` instead. ```

## Examples

collapse all

Create a vector and check if it is sorted in ascending order.

```A = [5 12 33 39 78 90 95 107]; issorted(A)```
```ans = logical 1 ```

Create a 5-by-5 matrix and check if each row is sorted in descending order.

`A = magic(5)`
```A = 17 24 1 8 15 23 5 7 14 16 4 6 13 20 22 10 12 19 21 3 11 18 25 2 9 ```
`issorted(A,2,'descend')`
```ans = logical 0 ```

Sort each row of `A` in descending order using the `sort` function, and check that the result has descending rows.

`B = sort(A,2,'descend')`
```B = 24 17 15 8 1 23 16 14 7 5 22 20 13 6 4 21 19 12 10 3 25 18 11 9 2 ```
`issorted(B,2,'descend')`
```ans = logical 1 ```

Create a 2-D array of strings and determine if each column is sorted.

`str = string({'Horse','Chicken';'cow','Goat'})`
```str = 2x2 string array "Horse" "Chicken" "cow" "Goat" ```
`issorted(str)`
```ans = logical 1 ```

Determine if the rows are sorted from left to right.

`issorted(str,2)`
```ans = logical 0 ```

Determine if each row is sorted in descending order from left to right.

`issorted(str,2,'descend')`
```ans = logical 1 ```

Create a vector containing complex numbers and `NaN` values.

`A = [NaN NaN 1+i 1+2i 2+2i 3+i];`

Check that the `NaN` elements are placed first within the vector, and that the remaining elements are sorted by real part.

`issorted(A,'MissingPlacement','first','ComparisonMethod','real')`
```ans = logical 1 ```

Since the third and fourth elements of `A` have equal real part, `issorted` checks if the imaginary part of these elements are also sorted.

`imag(A(3))`
```ans = 1 ```
`imag(A(4))`
```ans = 2 ```

## Input Arguments

collapse all

Input array, specified as a vector, matrix, multidimensional array, cell array of character vectors, or timetable.

• If `A` contains missing values, such as `NaN`, `NaT`, `<undefined>`, and `missing`, then by default, `issorted` requires that they are placed at the end to return 1.

• If `A` is complex, then by default, `issorted` determines sort order by the magnitude of the elements. If there are consecutive elements with equal magnitude, then `issorted` also checks the phase angle in the interval (-π, π] to break ties.

• If `A` is a cell array of character vectors or a string array, then `issorted` determines sort order using the code order for the UTF-16 character encoding scheme. The sort is case-sensitive. For more information on sorted character and string arrays, see Sort Order for Character and String Arrays.

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

Complex Number Support: Yes

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

Consider a matrix `A`. `issorted(A,1)` checks if the data in each column of `A` is sorted.

`issorted(A,2)` checks if the data in each row of `A` is sorted.

`dim` is not supported for timetable input.

Data Types: `double` | `single` | `int8` | `int16` | `int32` | `int64` | `uint8` | `uint16` | `uint32` | `uint64`

Sorting direction, specified as one of the following:

• `'ascend'` — Checks if data is in ascending order. Data can contain consecutive repeated elements.

• `'descend'` — Checks if data is in descending order. Data can contain consecutive repeated elements.

• `'monotonic'` — Checks if data is in descending or ascending order. Data can contain consecutive repeated elements.

• `'strictascend'` — Checks if data is in strictly ascending order. Elements must be unique.

• `'strictdescend'` — Checks if data is in strictly descending order. Elements must be unique.

• `'strictmonotonic'` — Checks if data is in strictly descending or strictly ascending order. Elements must be unique.

`direction` is not supported for timetable input. Use `issortedrows` instead.

### Name-Value Pair Arguments

Specify optional comma-separated pairs of `Name,Value` arguments. `Name` is the argument name and `Value` is the corresponding value. `Name` must appear inside single quotes (`' '`). You can specify several name and value pair arguments in any order as `Name1,Value1,...,NameN,ValueN`.

Example: `issorted(A,'MissingPlacement','last')`

collapse all

Placement of missing values (`NaN`, `NaT`, `<undefined>`, and `missing`) specified as the comma-separated pair consisting of `'MissingPlacement'` and one of the following:

• `'auto'` — Missing elements are required to be placed last for ascending order and first for descending order to return 1.

• `'first'` — Missing elements are required to be placed first to return 1.

• `'last'` — Missing elements are required to be placed last to return 1.

This name-value pair is not supported for timetable input. Use `issortedrows` instead.

Element comparison method, specified as the comma-separated pair consisting of `'ComparisonMethod'` and one of the following:

• `'auto'` — Check if `A` is sorted by `real(A)` when `A` is real, and check if `A` is sorted by `abs(A)` when `A` is complex.

• `'real'` — Check if `A` is sorted by `real(A)` when `A` is real or complex. If `A` has elements with consecutive equal real parts, then check `imag(A)` to break ties.

• `'abs'` — Check if `A` is sorted by `abs(A)` when `A` is real or complex. If `A` has elements with consecutive equal magnitude, then check `angle(A)` in the interval (-π,π] to break ties.

## More About

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.

## See Also

#### Introduced before R2006a

Was this topic helpful?

#### The Manager's Guide to Solving the Big Data Conundrum

Download white paper