sort

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

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

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

B = sort(___,direction) devuelve elementos ordenados de A en el orden que especifica direction utilizando cualquiera de las sintaxis anteriores. 'ascend' indica orden ascendente (el predeterminado) y 'descend' indica 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 recopilación de vectores índice para cualquiera de las sintaxis anteriores. I es del 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 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 matrices 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 matrices 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 un arreglo de cadenas

A partir de la versión R2017a, puede crear arreglos de cadenas utilizando comillas dobles y ordenarlos con la función sort. Ordene las cadenas en cada columna de un arreglo de cadenas según el orden del diccionario de Unicode®.

A = ["Santos","Burns"; ...
     "Jones","Morita"; ...
     "Petrov","Adams"];
B = sort(A)

B = 3x2 string
    "Jones"     "Adams" 
    "Petrov"    "Burns" 
    "Santos"    "Morita"

Ordene las cadenas en cada fila.

B = sort(A,2)

B = 3x2 string
    "Burns"    "Santos"
    "Jones"    "Morita"
    "Adams"    "Petrov"

Ordenar e indexar un arreglo `datetime`

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

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

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

[B,I] = sort(A)

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

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

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

A(I)

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

Ordenar vectores en el mismo orden

Cree dos vectores fila que contengan datos relacionados en los elementos correspondientes.

X = [3 6 4 2 1 5];
Y = ["yellow" "purple" "green" "orange" "red" "blue"];

Primero, ordene el vector X y, a continuación, ordene el vector Y en el mismo orden que X.

[Xsorted,I] = sort(X)

Xsorted = 1×6

     1     2     3     4     5     6

I = 1×6

     5     4     1     3     6     2

Ysorted = Y(I)

Ysorted = 1x6 string
    "red"    "orange"    "yellow"    "green"    "blue"    "purple"

Ordenar un arreglo 3D

Cree un arreglo 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 en columnas de A, para ordenar todos los elementos de A.

B = sort(A(:))

Vector complejo

Ordene los elementos de un vector complejo mediante sus partes reales. De forma predeterminada, la función sort ordena valores complejos por su magnitud, y resuelve los empates mediante ángulos de fase. Especifique el valor de 'ComparisonMethod' como 'real' para ordenar en su lugar valores complejos mediante sus partes reales. Para elementos con partes reales iguales, sort resuelve el empate basándose en sus partes imaginarias.

A = [1+2i 3+1i 1i 0 -1i];
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` — Arreglo de entrada
vector | matriz | arreglo multidimensional

Arreglo de entrada, especificado como vector, matriz o arreglo multidimensional.

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 la misma magnitud, los elementos se ordenan por ángulo de fase en el intervalo (−π, π].
Si A es un arreglo de celdas de vectores de caracteres o un arreglo de cadenas, sort(A) ordena los elementos según el orden del código del esquema de cifrado de caracteres UTF-16. El orden distingue entre mayúsculas y minúsculas. Para obtener más información sobre ordenar arreglos de caracteres y cadenas, consulte Orden de clasificación para arreglos de caracteres y cadenas.
Si A es un arreglo de cadenas, sort reordena los elementos del arreglo, pero no reordena los caracteres dentro de las cadenas.
Si A es un arreglo categórico, el orden de ordenación se basa en el orden de las categorías devuelto por categories(A).

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

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

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

sort devuelve A si dim es mayor que ndims(A). dim no es compatible cuando A es un arreglo de celdas, es decir, sort solo opera en la primera dimensión del arreglo cuyo tamaño no es igual a 1.

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

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

Argumentos de par nombre-valor

Especifique pares opcionales de argumentos como Name1=Value1,...,NameN=ValueN, donde Name es el nombre del argumento y Value es el valor correspondiente. Los argumentos nombre-valor deben aparecer después de otros argumentos, pero el orden de los pares no importa.

En las versiones anteriores a R2021a, utilice comas para separar cada nombre y valor, y encierre Name entre comillas.

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

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

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

'auto': los valores faltantes se colocan de últimos en orden ascendente y de primeros en orden descendente.
'first': los valores faltantes se colocan de primeros.
'last': los valores faltantes se colocan de últimos.

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

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

'auto': ordenar A mediante real(A) cuando A es real y mediante abs(A) cuando A es complejo.
'real': ordenar A mediante real(A) cuando A es real o complejo. Si A tiene elementos con las mismas partes reales, utilice imag(A) para resolver empates.
'abs': ordenar A mediante abs(A) cuando A es real o complejo. Si A tiene elementos con la misma magnitud, utilice angle(A) en el intervalo (-π,π] para resolver empates.

Argumentos de salida

`B` — Arreglo ordenado
vector | matriz | arreglo multidimensional

Arreglo ordenado, devuelto como vector, matriz o arreglo multidimensional. B es del mismo tamaño y tipo que A.

`I` — Índice ordenado
vector | matriz | arreglo multidimensional

Índice ordenado, devuelto como vector, matriz o arreglo multidimensional. I es del mismo tamaño que A. Los vectores índice están orientados 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 en cada fila de A. La salida I es una recopilación de vectores índice de fila de 1 por 3 que describe la redistribución de cada fila de A.

Cuando la entrada contiene valores repetidos, el índice ordenado conserva el orden original en la entrada, independientemente de la dirección de ordenación. Por ejemplo, si A = [1 2 1 2], [Ba,Ia] = sort(A,'ascend') devuelve el índice ordenado Ia = [1 3 2 4] y [Bd,Id] = sort(A,'descend') devuelve el índice ordenado Id = [2 4 1 3].

Más acerca de