sort

B = sort(A) ordena los elementos de A en orden ascendente.

Si A es un vector, sort(A) ordena los elementos vectoriales.
Si A es una matriz, sort(A) trata las columnas de A como vectores y ordena cada columna.
Si A es un array multidimensional, sort(A) opera a lo largo de la primera dimensión del array cuyo tamaño no sea igual a 1, tratando los elementos como vectores.

B = sort(A,dim) devuelve los elementos ordenados de A a lo largo de la dimensión dim. Por ejemplo, si A es una matriz, sort(A,2) ordena los elementos de cada fila.

B = sort(___,direction) devuelve los elementos ordenados de A en el orden especificado por direction utilizando cualquiera de las sintaxis anteriores. 'ascend' indica el orden ascendente (el valor predeterminado) y 'descend' indica el orden descendente.

B = sort(___,Name,Value) especifica parámetros adicionales para la ordenación. Por ejemplo, sort(A,'ComparisonMethod','abs') ordena los elementos de A por magnitud.

[B,I] = sort(___) también devuelve una colección de vectores de índice para cualquiera de las sintaxis anteriores. I tiene el mismo tamaño que A y describe la disposición de los elementos de A en B a lo largo de la dimensión ordenada. Por ejemplo, si A es un vector, B = A(I).

Ejemplos

Ordenar un vector en orden ascendente

Cree un vector de fila y ordene sus elementos en orden ascendente.

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

B = 1×9

   -10    -7     0     2     3     4     5     8     9

Ordenar filas de matriz en orden ascendente

Cree una matriz y ordene cada una de sus filas en orden ascendente.

A = [3 6 5; 7 -2 4; 1 0 -9]

A = 3×3

     3     6     5
     7    -2     4
     1     0    -9

B = sort(A,2)

B = 3×3

     3     5     6
    -2     4     7
    -9     0     1

Ordenar columnas de matriz en orden descendente

Cree una matriz y ordene sus columnas en orden descendente.

A = [10 -12 4 8; 6 -9 8 0; 2 3 11 -2; 1 1 9 3]

A = 4×4

    10   -12     4     8
     6    -9     8     0
     2     3    11    -2
     1     1     9     3

B = sort(A,'descend')

B = 4×4

    10     3    11     8
     6     1     9     3
     2    -9     8     0
     1   -12     4    -2

Ordenar array de cadenas

A partir de la versión R2016b, puede crear arrays de cadenas mediante la función string y ordenarlas mediante la función sort. Ordene las cadenas de cada columna de un array de cadenas de acuerdo con el orden de diccionario de Unicode®.

A = string({'Smith','Burns';...
    'Jones','Matthews';...
    'Peterson','Adams'});
B = sort(A)

B = 3x2 string array
    "Jones"       "Adams"   
    "Peterson"    "Burns"   
    "Smith"       "Matthews"

Ordene las cadenas de cada fila.

B = sort(A,2)

B = 3x2 string array
    "Burns"    "Smith"   
    "Jones"    "Matthews"
    "Adams"    "Peterson"

Las funciones de procesamiento de texto (como strfind y regexp) aceptan arrays de cadenas como entradas, pero otras funciones (por ejemplo, addpath) no lo hacen.

Ordenar e indexar un array `datetime`

Cree un array de valores datetime y ordénelos en orden ascendente, es decir, desde la fecha más antigua hasta la más reciente.

ds = {'2012-12-22';'2063-04-05';'1992-01-12'};
A = datetime(ds,'Format','yyyy-MM-dd')

A = 3x1 datetime array
   2012-12-22
   2063-04-05
   1992-01-12

[B,I] = sort(A)

B = 3x1 datetime array
   1992-01-12
   2012-12-22
   2063-04-05

B enumera las fechas ordenadas e I contiene los índices correspondientes de A.

Acceda directamente a los elementos ordenados desde el array original utilizando el array de índices I.

A(I)

ans = 3x1 datetime array
   1992-01-12
   2012-12-22
   2063-04-05

Ordenar un array 3D

Cree un array de 2 por 2 por 2 y ordene sus elementos en orden ascendente a lo largo de la tercera dimensión.

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

A = 
A(:,:,1) =

     2     3
     1     6


A(:,:,2) =

    -1     9
     0    12

B = sort(A,3)

B = 
B(:,:,1) =

    -1     3
     0     6


B(:,:,2) =

     2     9
     1    12

Utilice A(:), la representación de columna de A, para ordenar todos los elementos de A.

B = sort(A(:))

Vector complejo

Ordene los elementos de un vector complejo según sus partes reales. Para los elementos con partes reales iguales, sort deshace el empate basándose en sus partes imaginarias.

A = [1+2i 3+i i 0 -i];
B = sort(A,'ComparisonMethod','real')

B = 1×5 complex

   0.0000 - 1.0000i   0.0000 + 0.0000i   0.0000 + 1.0000i   1.0000 + 2.0000i   3.0000 + 1.0000i ⋯

Argumentos de entrada

`A` — Array de entrada
vector | matriz | array multidimensional | array de celdas de vectores de caracteres

Array de entrada, especificado como vector, matriz, array multidimensional o array de celdas de vectores de caracteres.

Si A es un escalar, sort(A) devuelve A.
Si A es complejo, de forma predeterminada sort ordena los elementos por magnitud. Si más de un elemento tiene igual magnitud, entonces los elementos se ordenan por ángulo de fase en el intervalo (−π, π].
Si A es un array de celdas de vectores de caracteres o un array de cadenas, sort(A) ordena los elementos según el orden de código para el esquema de codificación de caracteres UTF-16. Para la ordenación se distingue entre mayúsculas y minúsculas. Para obtener más información sobre la ordenación de arrays de caracteres y cadenas, consulte Orden de clasificación de arrays de caracteres y cadenas.
Si A es un array de cadenas, sort reordena los elementos del array, pero no reordena los caracteres dentro de las cadenas.

`dim` — Dimensión en la que operar
escalar entero positivo

Dimensión en la que operar, especificada como un escalar entero positivo. Si no se especifica ningún valor, la opción predeterminada es la primera dimensión del array cuyo tamaño no sea igual a 1.

Considere una matriz A. sort(A,1) ordena los elementos de las columnas de A.
sort(A,2) ordena los elementos de las filas de A.

sort devuelve A si dim es mayor que ndims(A). dim no se admite cuando A es un array de celdas, es decir, sort solo opera a lo largo de la primera dimensión del array cuyo tamaño no sea igual a 1.

`direction` — Dirección de ordenación
`'ascend'` (predeterminado) | `'descend'`

Dirección de ordenación, especificada como 'ascend' o 'descend'. direction no se admite cuando A es un array de celdas, es decir, sort solo ordena en orden ascendente.

Argumentos de par nombre-valor

Ejemplo: sort(A,'MissingPlacement','last')

`'MissingPlacement'` — Colocación de valores ausentes
`'auto'` (predeterminado) | `'first'` | `'last'`

Colocación de valores ausentes (NaN, NaT, <undefined> y missing), especificados como un par separado por comas que consta de 'MissingPlacement' y uno de los siguientes:

'auto': los elementos que faltan se colocan al final en el orden ascendente y al principio en el orden descendente.
'first': los elementos que faltan se colocan primero.
'last': los elementos que faltan se colocan al final.

`'ComparisonMethod'` — Método de comparación de elementos
`'auto'` (predeterminado) | `'real'` | `'abs'`

Método de comparación de elementos, especificado como un par separado por comas que consta de 'ComparisonMethod' y uno de los siguientes:

'auto': ordena A según real(A) cuando A es real, y lo ordena según abs(A) si A es complejo.
'real': ordena A según real(A) cuando A es real o complejo. Si A tiene elementos con partes reales iguales, utilice imag(A) para deshacer el empate.
'abs': ordena A según abs(A) cuando A es real o complejo. Si A tiene elementos de igual magnitud, utilice angle(A) en el intervalo (-π,π) para deshacer el empate.

Argumentos de salida

`B` — Array ordenado
vector | matriz | array multidimensional | array de celdas de vectores de caracteres

Array ordenado, devuelto como vector, matriz, array multidimensional o array de celdas de vectores de caracteres. B tiene el mismo tamaño y tipo que A. El orden de los elementos de B preserva el orden de todos los elementos iguales en A.

`I` — Clasificar índice
vector | matriz | array multidimensional

Clasificar un índice, devuelto como vector, matriz o array multidimensional. I tiene el mismo tamaño que A. Los vectores de índice se orientan a lo largo de la misma dimensión en la que opera sort. Por ejemplo, si A es una matriz de 2 por 3, [B,I] = sort(A,2) ordena los elementos de cada fila de A. La salida I es una colección de vectores de índice de fila de 1 por 3 que describe la reclasificación de cada fila de A.

Más acerca de