sort

B = sort(A) 按升序对 A 的元素进行排序。

如果 A 是向量，则 sort(A) 对向量元素进行排序。
如果 A 是矩阵，则 sort(A) 会将 A 的列视为向量并对每列进行排序。
如果 A 是多维数组，则 sort(A) 沿大小不等于 1 的第一个数组维度计算，并将这些元素视为向量。

B = sort(A,dim) 返回 A 沿维度 dim 的排序元素。例如，如果 A 是一个矩阵，则 sort(A,2) 对每行中的元素进行排序。

B = sort(___,direction) 使用上述任何语法返回按 direction 指定的顺序显示的 A 的有序元素。'ascend' 表示升序（默认值），'descend' 表示降序。

B = sort(___,Name,Value) 指定用于排序的其他参数。例如，sort(A,'ComparisonMethod','abs') 按模对 A 的元素进行排序。

[B,I] = sort(___) 还会为上述任意语法返回一个索引向量的集合。I 的大小与 A 的大小相同，它描述了 A 的元素沿已排序的维度在 B 中的排列情况。例如，如果 A 是一个向量，则 B = A(I)。

示例

按升序对向量排序

创建一个行向量，并按升序对其元素排序。

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

按升序对矩阵行排序

创建一个矩阵，并按升序对每一行排序。

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

按降序对矩阵列排序

创建一个矩阵，并按升序对每一列排序。

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

对字符串数组排序

从 R2017a 开始，您可以使用双引号创建字符串数组，并使用 sort 函数对它们进行排序。根据 Unicode® 字典顺序对字符串数组的每一列中的字符串进行排序。

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

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

对每一行中的字符串进行排序。

B = sort(A,2)

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

对 `datetime` 数组排序并进行索引

创建一个由 datetime 值构成的数组，然后按升序排序，也就是从最早到最近的日历日期排序。

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 列出排序后的日期以及包含 A 的相应索引的 I。

使用索引数组 I 从原始数组直接访问排序后的元素。

A(I)

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

按相同顺序对向量进行排序

创建两个在对应元素中包含相关数据的行向量。

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

首先对向量 X 进行排序，然后按照与 X 相同的顺序对向量 Y 进行排序。

[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"

对三维数组排序

创建一个 2×2×2 数组，并沿第三维度按升序对元素进行排序。

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

使用 A(:)（A 的列表示形式）对 A 的所有元素进行排序。

B = sort(A(:))

复数向量

按复数向量元素的实部对元素进行排序。默认情况下，sort 函数按复数值的幅值对其进行排序，再使用相位角对幅值相同的值继续排序。将 'ComparisonMethod' 的值指定为 'real'，以按复数值的实部对其排序。对于具有相等实部的元素，sort 将基于其虚部进行排序。

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

输入参数

`A` — 输入数组
向量 | 矩阵 | 多维数组

输入数组，指定为向量、矩阵或多维数组。

如果 A 是标量，则 sort(A) 返回 A。
如果 A 是复数，默认情况下，sort 会按模对元素进行排序。如果有多个元素具有相等的模，则按区间 (−π, π] 上的相位角对这些元素进行排序。
如果 A 是字符向量元胞数组或字符串数组，则 sort(A) 按照 UTF-16 字符编码方案的代码顺序对元素进行排序。排序区分大小写。有关对字符和字符串数组进行排序的详细信息，请参阅字符和字符串数组的排序顺序。
如果 A 是字符串数组，则 sort 将对数组元素重新排序，但不会对字符串中的字符重新排序。
如果 A 是分类数组，则排序顺序基于 categories(A) 返回的类别顺序。

`dim` — 沿其运算的维度
正整数标量

沿其运算的维度，指定为正整数标量。如果未指定值，则默认值是大小不等于 1 的第一个数组维度。

假定有矩阵 A。sort(A,1) 对 A 的列元素进行排序。
sort(A,2) 对 A 的行元素进行排序。

如果 dim 大于 ndims(A)，sort 将返回 A。当 A 是元胞数组时，不支持 dim，即，sort 仅沿其大小不等于 1 的第一个数组维度进行运算。

`direction` — 排序方向
`'ascend'` （默认） | `'descend'`

排序方向，指定为 'ascend' 或 'descend'。当 A 是元胞数组时，不支持 direction，即，sort 仅按升序排序。

名称-值参数

将可选的参数对组指定为 Name1=Value1,...,NameN=ValueN，其中 Name 是参数名称，Value 是对应的值。名称-值参数必须出现在其他参数之后，但参数对组的顺序无关紧要。

在 R2021a 之前，使用逗号分隔每个名称和值，并用引号将 Name 引起来。

示例： sort(A,'MissingPlacement','last')

`MissingPlacement` — 缺失值的位置
`'auto'` （默认） | `'first'` | `'last'`

缺失值（NaN、NaT、<undefined> 和 missing）的位置，指定为逗号分隔的对组，包含 'MissingPlacement' 和下列项之一：

'auto' - 缺失的元素放在最后（对于升序排序）或放在最前面（对于降序排序）。
'first' - 缺失的元素放在最前面。
'last' - 缺失的元素放在最后。

`ComparisonMethod` — 元素比较方法
`'auto'` （默认） | `'real'` | `'abs'`

元素比较方法，指定为逗号分隔的对组，包含 'ComparisonMethod' 和下列项之一：

'auto' - 当 A 为实数时，按 real(A) 对 A 进行排序；当 A 为复数时，按 abs(A) 进行排序。
'real' - 当 A 为实数或复数时，按 real(A) 对 A 进行排序。如果 A 包含具有相等实部的元素，则使用 imag(A) 进行排序。
'abs' - 当 A 为实数或复数时，按 abs(A) 对 A 进行排序。如果 A 包含具有相等模的元素，则使用区间 (-π,π] 中的 angle(A) 进行排序。

输出参数

`B` — 已排序数组
向量 | 矩阵 | 多维数组

已排序数组，以向量、矩阵或多维数组的形式返回。B 的大小和类型均与 A 相同。

`I` — 排序索引
向量 | 矩阵 | 多维数组

排序索引，以向量、矩阵或多维数组的形式返回。I 的大小与 A 相同。这些索引向量沿 sort 作用于的同一维度指定方向。例如，如果 A 是一个 2×3 矩阵，则 [B,I] = sort(A,2) 对 A 中的每行元素进行排序。输出 I 是 1×3 行索引向量的集合，用于描述 A 中每行元素的重新排列。

sort 函数使用一种稳定的排序算法。因此，当输入包含重复值时，无论排序方向如何，排序索引都会保留输入的原始顺序。例如，如果 A = [1 2 1 2]，则 [Ba,Ia] = sort(A,'ascend') 返回排序索引 Ia = [1 3 2 4]，[Bd,Id] = sort(A,'descend') 返回排序索引 Id = [2 4 1 3]。

详细信息