sortrows

对矩阵行或表行进行排序

全页折叠

语法

B = sortrows(A)

B = sortrows(A,column)

B = sortrows(A,___,direction)

B = sortrows(A,___,Name,Value)

[B,index] = sortrows(A,___)

tblB = sortrows(tblA)

tblB = sortrows(tblA,'RowNames')

tblB = sortrows(tblA,rowDimName)

tblB = sortrows(tblA,vars)

tblB = sortrows(tblA,___,direction)

tblB = sortrows(tblA,___,Name,Value)

[tblB,index] = sortrows(tblA,___)

说明

数组数据

B = sortrows(A) 基于第一列中的元素对数组的行进行排序。默认情况下，sortrows 使用升序排序。当第一列包含重复的元素时，sortrows 会根据下一列中的值进行排序，并对后续的相等值重复此行为。

示例

B = sortrows(A,column) 指定要作为行排序依据的列。例如，sortrows(A,[4 6]) 先基于第四列中的元素对 A 的行进行排序，然后基于第六列中的元素处理结值。

示例

B = sortrows(A,___,direction) 可在上述任一语法的基础上指定排序方向。例如，sortrows(A,'descend') 使用降序排序顺序。

示例

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

示例

[B,index] = sortrows(A,___) 还会返回描述行的重新排列的索引向量，以便 B = A(index,:)。

示例

表数据

tblB = sortrows(tblA) 对表或时间表中的行进行排序。

如果 tblA 是表，则 sortrows 基于第一个变量中的值对 tblA 进行升序排序。如果第一个变量中的元素重复，则 sortrows 按第二个变量中的元素排序，依此类推。
如果 tblA 是时间表，则 sortrows 将基于行时间按升序对 tblA 中的行进行排序。但是，这些行仅基于行时间进行排序。如果行时间重复，则 sortrows 不会按时间表变量中的元素排序。

示例

tblB = sortrows(tblA,'RowNames') 基于表的行名称对表进行排序。表的行名称沿表的第一个维度标记行。如果 tblA 不包含行名称，即，tblA.Properties.RowNames 为空，则 sortrows 返回 tblA。

当 tblA 是时间表时，不支持此语法。

示例

tblB = sortrows(tblA,rowDimName) 基于沿第一个维度上的行标签进行排序。

如果 tblA 是表，则行标签为行名称。
如果 tblA 是时间表，则行标签为行时间。

示例

tblB = sortrows(tblA,vars) 基于指定的表变量进行排序。例如，sortrows(tblA,{'Var1','Var2'}) 首先基于 Var1 中的元素，然后基于 Var2 中的元素对 tblA 的行进行排序。

如果 tblA 是包含行名称的表，则 vars 可以包含行名称。
如果 tblA 是时间表，则 vars 可以包括行时间。

示例

对于上述任一表语法，tblB = sortrows(tblA,___,direction) 对 tblA 中的行按指定方向排序。

示例

tblB = sortrows(tblA,___,Name,Value) 指定用于对表或时间表的行进行排序的其他参数。例如，sortrows(tblA,'Var1','MissingPlacement','first') 基于 Var1 中的元素进行排序，将 NaN 等缺失的元素排在表的开头。

示例

[tblB,index] = sortrows(tblA,___) 还返回一个索引向量以使 tblB = tblA(index,:)。

示例

全部折叠

对矩阵行排序

打开实时脚本

创建矩阵，并基于第一列中的元素按升序对矩阵行进行排序。当第一列包含重复的元素时，sortrows 会基于第二列中的元素进行排序。对于第二列中的重复元素，sortrows 会基于第三列进行排序，依此类推。

rng default;
A = floor(rand([6 7])*100);
A(1:4,1) = 95;  A(5:6,1) = 76;  A(2:4,2) = 7;  A(3,3) = 48

A = 6×7

    95    27    95    79    67    70    69
    95     7    48    95    75     3    31
    95     7    48    65    74    27    95
    95     7    14     3    39     4     3
    76    15    42    84    65     9    43
    76    97    91    93    17    82    38

B = sortrows(A)

B = 6×7

    76    15    42    84    65     9    43
    76    97    91    93    17    82    38
    95     7    14     3    39     4     3
    95     7    48    65    74    27    95
    95     7    48    95    75     3    31
    95    27    95    79    67    70    69

基于第二列中的值对 A 的行排序。当指定的列包含重复元素时，对应的行将保持其原始顺序。

C = sortrows(A,2)

C = 6×7

    95     7    48    95    75     3    31
    95     7    48    65    74    27    95
    95     7    14     3    39     4     3
    76    15    42    84    65     9    43
    95    27    95    79    67    70    69
    76    97    91    93    17    82    38

基于第一列中的元素对 A 的行进行排序，如果第一列中包含相同元素，则按第七列进行排序。

D = sortrows(A,[1 7])

D = 6×7

    76    97    91    93    17    82    38
    76    15    42    84    65     9    43
    95     7    14     3    39     4     3
    95     7    48    95    75     3    31
    95    27    95    79    67    70    69
    95     7    48    65    74    27    95

基于第四列中的元素以降序对 A 的行进行排序，并显示输出向量 index 以查看行是如何重新排列的。

[E,index] = sortrows(A,4,'descend')

E = 6×7

    95     7    48    95    75     3    31
    76    97    91    93    17    82    38
    76    15    42    84    65     9    43
    95    27    95    79    67    70    69
    95     7    48    65    74    27    95
    95     7    14     3    39     4     3

index = 6×1

     2
     6
     5
     1
     3
     4

复矩阵

打开实时脚本

创建一个包含复数的矩阵，并基于第一列中的元素按升序对矩阵行进行排序。由于 A(1,1) 和 A(3,1) 的模相等，因此 sortrows 会计算它们的角度以进行排序。

A = [1+2i 3+i i; 2+10i 6i 2+5i; 2+i 4 3+3i]

A = 3×3 complex

   1.0000 + 2.0000i   3.0000 + 1.0000i   0.0000 + 1.0000i
   2.0000 +10.0000i   0.0000 + 6.0000i   2.0000 + 5.0000i
   2.0000 + 1.0000i   4.0000 + 0.0000i   3.0000 + 3.0000i

B = sortrows(A)

B = 3×3 complex

   2.0000 + 1.0000i   4.0000 + 0.0000i   3.0000 + 3.0000i
   1.0000 + 2.0000i   3.0000 + 1.0000i   0.0000 + 1.0000i
   2.0000 +10.0000i   0.0000 + 6.0000i   2.0000 + 5.0000i

angle(A(1,1))

ans = 
1.1071

angle(A(3,1))

ans = 
0.4636

可使用 'real' 选项按 A 行的实部对这些行进行排序。由于 A(2,1) 和 A(3,1) 具有相同的实部，sortrows 将使用虚部进行排序。

C = sortrows(A,'ComparisonMethod','real')

C = 3×3 complex

   1.0000 + 2.0000i   3.0000 + 1.0000i   0.0000 + 1.0000i
   2.0000 + 1.0000i   4.0000 + 0.0000i   3.0000 + 3.0000i
   2.0000 +10.0000i   0.0000 + 6.0000i   2.0000 + 5.0000i

imag(A(2,1))

ans = 
10

imag(A(3,1))

ans = 
1

对字符串数组的行进行排序

打开实时脚本

创建一个 6×2 字符串数组。基于第一列中的元素按字母升序对其行进行排序。当第一列包含重复元素时，使用第二列处理结值。

A = ["B" "Y"; "B" "Z"; "A" "Z"; ...
     "B" "X"; "A" "Y"; "A" "X"];
B1 = sortrows(A)

B1 = 6×2 string
    "A"    "X"
    "A"    "Y"
    "A"    "Z"
    "B"    "X"
    "B"    "Y"
    "B"    "Z"

再次对行进行排序。这次，通过按字母降序对第二列中的元素进行排序来处理第一列中元素的结值。

B2 = sortrows(A,[1 2],["ascend" "descend"])

B2 = 6×2 string
    "A"    "Z"
    "A"    "Y"
    "A"    "X"
    "B"    "Z"
    "B"    "Y"
    "B"    "X"

对表行排序

打开实时脚本

按变量值对表行进行排序。

创建一个表，其中包含列出五位病患信息的四个变量。

LastName = {'Smith';'Johnson';'Williams';'Jones';'Brown'};
Age = [38;43;38;40;49];
Height = [71;69;64;67;64];
Weight = [176;163;131;133;119];
BloodPressure = [124 93; 109 77; 125 83; 117 75; 122 80];

tblA = table(Age,Height,Weight,BloodPressure,'RowNames',LastName)

tblA=5×4 table
                Age    Height    Weight    BloodPressure
                ___    ______    ______    _____________

    Smith       38       71       176       124     93  
    Johnson     43       69       163       109     77  
    Williams    38       64       131       125     83  
    Jones       40       67       133       117     75  
    Brown       49       64       119       122     80

对该表的行排序。sortrows 函数首先按变量 Age 以升序对行进行排序，然后按变量 Height 对具有相等年龄的两行进行排序。

tblB = sortrows(tblA)

tblB=5×4 table
                Age    Height    Weight    BloodPressure
                ___    ______    ______    _____________

    Williams    38       64       131       125     83  
    Smith       38       71       176       124     93  
    Jones       40       67       133       117     75  
    Johnson     43       69       163       109     77  
    Brown       49       64       119       122     80

按行名称对表行排序

打开实时脚本

创建一个表，其中包含列出五位病患信息的四个变量。

LastName = {'Smith';'Johnson';'Williams';'Jones';'Brown'};
Age = [38;43;38;40;49];
Height = [71;69;64;67;64];
Weight = [176;163;131;133;119];
BloodPressure = [124 93; 109 77; 125 83; 117 75; 122 80];

tblA = table(Age,Height,Weight,BloodPressure,'RowNames',LastName)

tblA=5×4 table
                Age    Height    Weight    BloodPressure
                ___    ______    ______    _____________

    Smith       38       71       176       124     93  
    Johnson     43       69       163       109     77  
    Williams    38       64       131       125     83  
    Jones       40       67       133       117     75  
    Brown       49       64       119       122     80

基于行名称按升序对表行进行排序，并返回描述行重新排列方式的索引向量。

[tblB,index] = sortrows(tblA,'RowNames')

tblB=5×4 table
                Age    Height    Weight    BloodPressure
                ___    ______    ______    _____________

    Brown       49       64       119       122     80  
    Johnson     43       69       163       109     77  
    Jones       40       67       133       117     75  
    Smith       38       71       176       124     93  
    Williams    38       64       131       125     83

index = 5×1

     5
     2
     4
     1
     3

按变量对表行进行排序

打开实时脚本

创建一个表，其中包含列出五位病患信息的四个变量。

LastName = {'Sweet';'Jacobson';'Wang';'Joiner';'Berger'};
Age = [38;43;38;40;49];
Height = [71;69;64;67;64];
Weight = [176;163;131;133;119];
BloodPressure = [124 93; 109 77; 125 83; 117 75; 122 80];

tblA = table(Age,Height,Weight,BloodPressure,'RowNames',LastName)

tblA=5×4 table
                Age    Height    Weight    BloodPressure
                ___    ______    ______    _____________

    Sweet       38       71       176       124     93  
    Jacobson    43       69       163       109     77  
    Wang        38       64       131       125     83  
    Joiner      40       67       133       117     75  
    Berger      49       64       119       122     80

按 Height 以升序对表行排序，然后按 Weight 以降序排序。

tblB = sortrows(tblA,{'Height','Weight'},{'ascend','descend'})

tblB=5×4 table
                Age    Height    Weight    BloodPressure
                ___    ______    ______    _____________

    Wang        38       64       131       125     83  
    Berger      49       64       119       122     80  
    Joiner      40       67       133       117     75  
    Jacobson    43       69       163       109     77  
    Sweet       38       71       176       124     93

包含缺失元素的表

打开实时脚本

创建一个表，其中包含列出五位病患信息的四个变量。Weight 变量包含缺失值。

LastName = {'Sweet';'Jacobson';'Wang';'Joiner';'Berger'};
Age = [38;43;38;40;49];
Height = [71;69;64;67;64];
Weight = [176;NaN;131;133;NaN];
BloodPressure = [124 93; 109 77; 125 83; 117 75; 122 80];
tblA = table(Age,Height,Weight,BloodPressure,'RowNames',LastName)

tblA=5×4 table
                Age    Height    Weight    BloodPressure
                ___    ______    ______    _____________

    Sweet       38       71       176       124     93  
    Jacobson    43       69       NaN       109     77  
    Wang        38       64       131       125     83  
    Joiner      40       67       133       117     75  
    Berger      49       64       NaN       122     80

按 Weight 以升序对表行进行排序，将包含 NaN 的行放在最前面。

tblB = sortrows(tblA,'Weight','MissingPlacement','first')

tblB=5×4 table
                Age    Height    Weight    BloodPressure
                ___    ______    ______    _____________

    Jacobson    43       69       NaN       109     77  
    Berger      49       64       NaN       122     80  
    Wang        38       64       131       125     83  
    Joiner      40       67       133       117     75  
    Sweet       38       71       176       124     93

对时间表行进行排序

打开实时脚本

创建一个时间表，并按行时间对行进行排序。

TimeDuration = [hours(3) hours(2) hours(1) hours(5) hours(6)]';
TT = timetable(TimeDuration,[98;97.5;97.9;98.1;101],[120;111;119;117;118]);
           
B = sortrows(TT,'TimeDuration')

B=5×2 timetable
    TimeDuration    Var1    Var2
    ____________    ____    ____

    1 hr            97.9    119 
    2 hr            97.5    111 
    3 hr              98    120 
    5 hr            98.1    117 
    6 hr             101    118

输入参数

全部折叠

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

输入数组，指定为列向量或矩阵。

`column` — 列排序向量
非零整数标量 | 非零整数向量

列排序向量，指定为非零整数标量或非零整数向量。每个指定的整数值指示一个按其排序的列。负整数表示排序顺序为降序。

`direction` — 排序方向
`'ascend'` (默认) | `'descend'` | 字符串数组 | 字符向量元胞数组

排序方向，指定为 'ascend'、'descend'，或指定这些值的组合的字符串数组或字符向量元胞数组。

如果 direction 是 'ascend' 或 'descend'，则排序方向适用于所有列排序向量或排序变量。如果 direction 是字符串数组或字符向量元胞数组，则每个条目对应于列排序向量或排序变量。

如果同时指定 column 和 direction，则 direction 确定排序方向，sortrows 忽略 column 中元素的符号。

示例: sortrows(X,[2 3],{'ascend' 'descend'}) 首先根据 X 的第 2 列对行进行升序排序。然后，根据第 3 列对第 2 列中具有相同条目的行按降序排序。

`tblA` — 输入表
表 | 时间表

输入表，指定为表或时间表。tblA 中的每个变量必须是 sort 或 sortrows 的有效输入。

`rowDimName` — 输入表或时间表的第一个维度的名称
字符串标量 | 字符向量

输入表或时间表的第一个维度的名称，指定为字符串标量或字符向量。

如果 tblA 是包含行名称的表，则 rowDimName 是表的第一个维度的名称。默认情况下，第一个维度的名称为 "Row"。维度名称是表的属性。您可以使用 tblA.Properties.DimensionNames 访问 tblA 的维度名称。
如果 tblA 是时间表，则 rowDimName 是行时间向量的名称。您可以在创建时间表时指定其名称，例如 Time 或 Date。也可以使用 tblA.Properties.DimensionNames 访问维度名称。

示例: 如果表 T 具有行名称，并且您使用 T.Properties.DimensionName{1} = "Name" 更改了第一个维度的名称，则 sortrows(T,"Name") 会按行名称对表进行排序。

示例: 如果时间表 TT 具有名为 Date 的时间向量，则 sortrows(TT,"Date") 将按 Date 中包含的日期和时间对时间表进行排序。

数据类型: string | char

`vars` — 排序变量
整数标量 | 整数向量 | 变量名称 | 变量名称的字符串数组 | 变量名称元胞数组 | `pattern` 标量 | 逻辑向量

排序变量，指定为整数标量、整数向量、变量名称、变量名称的字符串数组、变量名称元胞数组、pattern 标量或逻辑向量。vars 指示要按其排序的表变量。

如果不指定 direction 参量，则 vars 中元素的符号确定变量的排序方向。如果一个元素为正整数，则 sortrows 按升序对 tblA 中的相应变量排序。如果一个元素为负整数，则 sortrows 按降序对 tblA 中的相应变量排序。否则，如果指定 direction 参量，sortrows 将忽略 vars 的符号，并根据 direction 对指定的变量进行排序。

示例: sortrows(tblA,["Height","Weight"]) 首先按变量 Height，然后按变量 Weight 以升序对 tblA 的行进行排序。

示例: sortrows(tblA,"X" + wildcardPattern) 按名称以字母 "X" 开头的表变量，使用通配符模式匹配名称中的其余字母，对 tblA 的行按升序排序。

示例: sortrows(tblA,[1 4]) 先按 tblA 的第一个变量以升序排序，如果第一个变量相同，再按第四个变量排序。

示例: sortrows(TT,["Time","X"]) 先按升序对时间表 TT 的行时间进行排序，然后再按表变量 X 进行排序。

名称-值参数

全部折叠

以 Name1=Value1,...,NameN=ValueN 的形式指定可选参量对组，其中 Name 是参量名称，Value 是对应的值。名称-值参量必须出现在其他参量之后，但对各个参量对组的顺序没有要求。

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

示例: sortrows(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 大小相同。

`tblB` — 已排序表
表 | 时间表

已排序的表，返回为与 tblA 具有相同变量的表或时间表。

`index` — 排序索引
列向量

排序索引，以列向量形式返回。排序索引描述输入中的行的重新排列，以便 B = A(index,:)。

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

数据类型: double

扩展功能

全部展开

tall 数组
对行数太多而无法放入内存的数组进行计算。

sortrows 函数支持 tall 数组，但存在以下使用说明和限制：

不支持按行名称排序。

有关详细信息，请参阅tall 数组。

C/C++ 代码生成
使用 MATLAB® Coder™ 生成 C 代码和 C++ 代码。

用法说明和限制：

不支持元胞或字符串输入数组。
如果 A 是虚部全部为零的复数，则 MATLAB^® 可能会在调用 sortrows(A) 之前将 A 转换为 real(A)。在这种情况下，MATLAB 按 real(A) 对 A 的行进行排序，但生成的代码按 abs(A) 对 A 的行进行排序。要使生成的代码与 MATLAB 匹配，请使用 sortrows(real(A)) 或 sortrows(A,'ComparisonMethod','real')。请参阅具有零值虚部的复数数据的代码生成 (MATLAB Coder)。
如果 tblA 是表或时间表，则输入参量 vars 必须为常量。
如果 tblA 是表或时间表，并且它有一个由多列字符向量组成的元胞数组形式的变量，则无法使用该变量中的值对 tblA 进行排序。
vars 输入参量不支持模式表达式。

GPU 代码生成
使用 GPU Coder™ 为 NVIDIA® GPU 生成 CUDA® 代码。

用法说明和限制：

第一个输入参量不能是元胞数组。
如果 A 是虚部全部为零的复数，则 MATLAB 可能会在调用 sortrows(A) 之前将 A 转换为 real(A)。在这种情况下，MATLAB 按 real(A) 对 A 的行进行排序，但生成的代码按 abs(A) 对 A 的行进行排序。要使生成的代码与 MATLAB 匹配，请使用 sortrows(real(A)) 或 sortrows(A,'ComparisonMethod','real')。

基于线程的环境
使用 MATLAB® `backgroundPool` 在后台运行代码或使用 Parallel Computing Toolbox™ `ThreadPool` 加快代码运行速度。

此函数完全支持基于线程的环境。有关详细信息，请参阅在基于线程的环境中运行 MATLAB 函数。

GPU 数组
通过使用 Parallel Computing Toolbox™ 在图形处理单元 (GPU) 上运行来加快代码执行。

sortrows 函数支持 GPU 数组输入，但有以下用法说明和限制：

不支持对元胞数组进行排序。
不支持稀疏输入。

有关详细信息，请参阅在 GPU 上运行 MATLAB 函数 (Parallel Computing Toolbox)。

分布式数组
使用 Parallel Computing Toolbox™ 在集群的组合内存中对大型数组进行分区。

用法说明和限制：

不支持对元胞数组进行排序。
不支持表、时间表、日期时间和持续时间输入。

有关详细信息，请参阅使用分布式数组运行 MATLAB 函数 (Parallel Computing Toolbox)。

版本历史记录

在 R2006a 之前推出

另请参阅

issortedrows | sort | issorted | topkrows

sortrows

语法

说明

数组数据

表数据

示例

对矩阵行排序

复矩阵

对字符串数组的行进行排序

对表行排序

按行名称对表行排序

按变量对表行进行排序

包含缺失元素的表

对时间表行进行排序

输入参数

A — 输入数组 列向量 | 矩阵

column — 列排序向量 非零整数标量 | 非零整数向量

direction — 排序方向 'ascend' (默认) | 'descend' | 字符串数组 | 字符向量元胞数组

tblA — 输入表 表 | 时间表

rowDimName — 输入表或时间表的第一个维度的名称 字符串标量 | 字符向量

vars — 排序变量 整数标量 | 整数向量 | 变量名称 | 变量名称的字符串数组 | 变量名称元胞数组 | pattern 标量 | 逻辑向量

名称-值参数

MissingPlacement — 缺失值的位置 'auto' (默认) | 'first' | 'last'

ComparisonMethod — 元素比较方法 'auto' (默认) | 'real' | 'abs'

输出参量

B — 已排序数组 列向量 | 矩阵

tblB — 已排序表 表 | 时间表

index — 排序索引 列向量

扩展功能

tall 数组 对行数太多而无法放入内存的数组进行计算。

C/C++ 代码生成 使用 MATLAB® Coder™ 生成 C 代码和 C++ 代码。

GPU 代码生成 使用 GPU Coder™ 为 NVIDIA® GPU 生成 CUDA® 代码。

基于线程的环境 使用 MATLAB® backgroundPool 在后台运行代码或使用 Parallel Computing Toolbox™ ThreadPool 加快代码运行速度。

GPU 数组 通过使用 Parallel Computing Toolbox™ 在图形处理单元 (GPU) 上运行来加快代码执行。

分布式数组 使用 Parallel Computing Toolbox™ 在集群的组合内存中对大型数组进行分区。

版本历史记录

另请参阅

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

`column` — 列排序向量
非零整数标量 | 非零整数向量

`direction` — 排序方向
`'ascend'` (默认) | `'descend'` | 字符串数组 | 字符向量元胞数组

`tblA` — 输入表
表 | 时间表

`rowDimName` — 输入表或时间表的第一个维度的名称
字符串标量 | 字符向量

`vars` — 排序变量
整数标量 | 整数向量 | 变量名称 | 变量名称的字符串数组 | 变量名称元胞数组 | `pattern` 标量 | 逻辑向量

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

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

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

`tblB` — 已排序表
表 | 时间表

`index` — 排序索引
列向量

tall 数组
对行数太多而无法放入内存的数组进行计算。

C/C++ 代码生成
使用 MATLAB® Coder™ 生成 C 代码和 C++ 代码。

GPU 代码生成
使用 GPU Coder™ 为 NVIDIA® GPU 生成 CUDA® 代码。

基于线程的环境
使用 MATLAB® `backgroundPool` 在后台运行代码或使用 Parallel Computing Toolbox™ `ThreadPool` 加快代码运行速度。

GPU 数组
通过使用 Parallel Computing Toolbox™ 在图形处理单元 (GPU) 上运行来加快代码执行。

分布式数组
使用 Parallel Computing Toolbox™ 在集群的组合内存中对大型数组进行分区。