【MATLAB第73期】# 源码分享 | 基于MATLAB的不同类型数据排列方式合集

【MATLAB第73期】# 源码分享 | 基于MATLAB的不同类型数据排列方式合集

学习参考链接

1.对数组的行进行排序（单元格/字符串/类别/表）
2.按字符代码对文本进行排序
3.对文件名、文件夹名或文件路径进行排序
4.对字符串/单元格/分类数组的元素进行排序

一、改进后的排列方式

X = {'A2','X';'A10','Y';'A10','X';'A1','X'};
sortrows(X) % 错误排序
    {'A1' }    {'X'}
    {'A10'}    {'X'}
    {'A10'}    {'Y'}
    {'A2' }    {'X'}
natsortrows(X) % 正确排序
    {'A1' }    {'X'}
    {'A2' }    {'X'}
    {'A10'}    {'X'}
    {'A10'}    {'Y'}

1.要排序的数组

第一个输入必须是以下数组类型之一：

*字符矩阵，
*字符行矢量的单元阵列，
*一个单元格数组，其列仅由字符行组成
矢量或纯数字标量：

第一个输入必须是矩阵（即仅二维）。

排序后的数组将作为第一个输出参数返回，例如：

A = {'B','2','X';'A','100','X';'B','10','X';'A','2','Y';'A','20','X'};
natsortrows(categorical(A)) %
     A      2        Y 
     A      20       X 
     A      100      X 
     B      2        X 
     B      10       X 

2.小数表达式

B = {'1.3','X';'1.10','X';'1.2','X'}
natsortrows(B)%默认情况下仅匹配整数。
    {'1.2' }    {'X'}
    {'1.3' }    {'X'}
    {'1.10'}    {'X'}
natsortrows(B, '\d+\.?\d*')%匹配小数。
    {'1.10'}    {'X'}
    {'1.2' }    {'X'}
    {'1.3' }    {'X'}

3.指定要排序的列

如果需要，可以使用以下方法之一指定要排序的列：

输入数组各列索引的逻辑矢量。
输入数组各列的索引的数字矢量，其中，正整数按升序对相应列进行排序
负整数按降序对相应列进行排序。这对应于|SORTROWS|columns|选项。
例如，第二列按升序排序，第三列按降序排序：

sortrows(A, [2,-3]) %编号顺序错误。
    {'B'}    {'10' }    {'X'}
    {'A'}    {'100'}    {'X'}
    {'A'}    {'2'  }    {'Y'}
    {'B'}    {'2'  }    {'X'}
    {'A'}    {'20' }    {'X'}
natsortrows(A, [], [2,-3])%正确的数字顺序。
    {'A'}    {'2'  }    {'Y'}
    {'B'}    {'2'  }    {'X'}
    {'B'}    {'10' }    {'X'}
    {'A'}    {'20' }    {'X'}
    {'A'}    {'100'}    {'X'}

4.指定排序方向

|SORTROWS||direction|选项是受支持的，其中字符向量|‘ascend’|、|‘descend’|和/或|‘ignore’|指定要排序的列的排序方向（这意味着
列或由|column|或|vars|选项指定的列）。

在这些示例中，第二列按升序排序，第三列按降序排序：

natsortrows(A, [], [2,3], {'ascend','descend'})
    {'A'}    {'2'  }    {'Y'}
    {'B'}    {'2'  }    {'X'}
    {'B'}    {'10' }    {'X'}
    {'A'}    {'20' }    {'X'}
    {'A'}    {'100'}    {'X'}

natsortrows(A, [], [false,true,true], {'ascend','descend'})
    {'A'}    {'2'  }    {'Y'}
    {'B'}    {'2'  }    {'X'}
    {'B'}    {'10' }    {'X'}
    {'A'}    {'20' }    {'X'}
    {'A'}    {'100'}    {'X'}
natsortrows(A, [], {'ignore','ascend','descend'})
    {'A'}    {'2'  }    {'Y'}
    {'B'}    {'2'  }    {'X'}
    {'B'}    {'10' }    {'X'}
    {'A'}    {'20' }    {'X'}
    {'A'}    {'100'}    {'X'}

5.表行名称

|SORTROWS||表支持“RowNames”|选项，可以作为literal text |‘RowNames’|或作为表的第一个维度的名称
即|SORTROWS||rowDimName|选项）。

T = cell2table(A,'RowNames',{'R20','R1','R10','R2','R9'},'VariableNames',{'V1','V2','V3'})
natsortrows(T, [], 'RowNames')
            V1        V2        V3  
           _____    _______    _____

    R1     {'A'}    {'100'}    {'X'}
    R2     {'A'}    {'2'  }    {'Y'}
    R9     {'A'}    {'20' }    {'X'}
    R10    {'B'}    {'10' }    {'X'}
    R20    {'B'}    {'2'  }    {'X'}
natsortrows(T, [], 'Row') %第一维度名称
            V1        V2        V3  
           _____    _______    _____

    R1     {'A'}    {'100'}    {'X'}
    R2     {'A'}    {'2'  }    {'Y'}
    R9     {'A'}    {'20' }    {'X'}
    R10    {'B'}    {'10' }    {'X'}
    R20    {'B'}    {'2'  }    {'X'}

6.表变量名称

|SORTROWS||vars|选项支持用于表，即：
表变量中索引的逻辑或数字矢量。
要排序的一个表变量的名称。
要排序的表变量的一个或多个名称的单元格数组。

natsortrows(T, [], {'V2','V3'},{'ascend','descend'})
            V1        V2        V3  
           _____    _______    _____

    R2     {'A'}    {'2'  }    {'Y'}
    R20    {'B'}    {'2'  }    {'X'}
    R10    {'B'}    {'10' }    {'X'}
    R9     {'A'}    {'20' }    {'X'}
    R1     {'A'}    {'100'}    {'X'}
natsortrows(T, [], [2,3], {'ascend','descend'})
            V1        V2        V3  
           _____    _______    _____

    R2     {'A'}    {'2'  }    {'Y'}
    R20    {'B'}    {'2'  }    {'X'}
    R10    {'B'}    {'10' }    {'X'}
    R9     {'A'}    {'20' }    {'X'}
    R1     {'A'}    {'100'}    {'X'}

7.单元格数组中的数字标量

对单元格数组进行排序时，只由数字组成的任何列或者可以通过选择|‘SortNum’|选项对逻辑标量进行排序。
混合单元阵列的示例，其中第1列完全由字符行矢量和第二列完全由数字标量组成：

C = {'A2',2;'A10',1;'A2',1}
natsortrows(C,[],'SortNum')
    {'A2' }    {[1.00]}
    {'A2' }    {[2.00]}
    {'A10'}    {[1.00]}

8.可选参数

进一步的输入直接传递到|NATSORT|，从而进行控制区分大小写、排序方向和其他选项。请参阅|NATSORT|有关支持选项的解释和示例的帮助：

D = {'B','X';'10','X';'1','X';'A','X';'2','X'}
natsortrows(D, [], 'descend')
    {'B' }    {'X'}
    {'A' }    {'X'}
    {'10'}    {'X'}
    {'2' }    {'X'}
    {'1' }    {'X'}
natsortrows(D, [], 'char)

    {'A' }    {'X'}
    {'B' }    {'X'}
    {'1' }    {'X'}
    {'2' }    {'X'}
    {'10'}    {'X'}

9.排序索引

第二个输出参数是排序索引|ndx|的数字数组，使得|Y=X（ndx，：）|其中|Y=natsortrows（X）|：

E = {'abc2xyz','Y';'abc10xy99','X';'abc2xyz','X';'abc1xyz','X'}
[out,ndx] = natsortrows(E)
out =
    {'abc1xyz'  }    {'X'}
    {'abc2xyz'  }    {'X'}
    {'abc2xyz'  }    {'Y'}
    {'abc10xy99'}    {'X'}


ndx =
          4.00
          3.00
          1.00
          2.00

10.调试阵列

第三个输出是单元阵列的单元矢量，其中单元阵列对应于输入单元阵列|X|的列。
单元格数组包含所有匹配的数字（转换为使用指定|SSCANF|格式的数字）和所有非数字子字符串。这些单元阵列有助于确认小数表达式正在正确识别数字。

[~,~,dbg] = natsortrows(E);
    {'abc'}    {[ 2.00]}    {'xyz'}    {0×0 double}
    {'abc'}    {[10.00]}    {'xy' }    {[   99.00]}
    {'abc'}    {[ 2.00]}    {'xyz'}    {0×0 double}
    {'abc'}    {[ 1.00]}    {'xyz'}    {0×0 double}
dbg{:}
    {'Y'}
    {'X'}
    {'X'}
    {'X'}

11.小数表达式：十进制小数，E表示法，+/-符号。

|NATSORTROWS|数字匹配可以自定义为检测数字十进制分数、E表示法、+/-号、二进制/十六进制或其他所需的功能。使用适当的小数表达式，有关详细信息和示例，请参见|NATSORT|。

F = {'v10.2','b'; 'v2.5','b'; 'v2.40','a'; 'v1.9','b'}
natsortrows(F) %默认匹配整数，例如版本号。
    {'v1.9' }    {'b'}
    {'v2.5' }    {'b'}
    {'v2.40'}    {'a'}
    {'v10.2'}    {'b'}
natsortrows(F,'\d+\.?\d*') %与小数部分匹配
    {'v1.9' }    {'b'}
    {'v2.40'}    {'a'}
    {'v2.5' }    {'b'}
    {'v10.2'}    {'b'}

12.交互式小数表达式工具

小数表达式功能强大且紧凑，但正确使用它们并不总是那么容易。一个帮助是下载交互式工具https://www.mathworks.com/matlabcentral/fileexchange/48930|IREGEXP|
它可以让您快速尝试不同的小数表达式，并查看所有在键入时显示和更新输出。
https://www.mathworks.com/help/matlab/ref/regexp.html|REGEXP|

二、基础排列方式

1.对矩阵行排序

创建矩阵，并基于第一列中的元素按升序对矩阵行进行排序。当第一列包含重复的元素时，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

2.对元胞数组行排序

创建一个 6×2 字符向量元胞数组，并对其行进行排序。结果是一个同时按国家/地区和名称排序的字母顺序列表。

A = {‘Germany’ ‘Lukas’; ‘USA’ ‘William’; ‘USA’ ‘Andrew’; …
‘Germany’ ‘Andreas’; ‘USA’ ‘Olivia’; ‘Germany’ ‘Julia’}
A = 6x2 cell
{‘Germany’} {‘Lukas’ }
{‘USA’ } {‘William’}
{‘USA’ } {‘Andrew’ }
{‘Germany’} {‘Andreas’}
{‘USA’ } {‘Olivia’ }
{‘Germany’} {‘Julia’ }

B = sortrows(A)
B = 6x2 cell
{‘Germany’} {‘Andreas’}
{‘Germany’} {‘Julia’ }
{‘Germany’} {‘Lukas’ }
{‘USA’ } {‘Andrew’ }
{‘USA’ } {‘Olivia’ }
{‘USA’ } {‘William’}

按照降序顺序，先对国家/地区进行排序，然后对名称进行排序。

C = sortrows(A,[1 2],{‘ascend’ ‘descend’})
C = 6x2 cell
{‘Germany’} {‘Lukas’ }
{‘Germany’} {‘Julia’ }
{‘Germany’} {‘Andreas’}
{‘USA’ } {‘William’}
{‘USA’ } {‘Olivia’ }
{‘USA’ } {‘Andrew’ }

3.对表行排序

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

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

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  

4.按行名称对表行排序

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

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

5.按变量对表行进行排序

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

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  

6.包含缺失元素的表

创建一个表，其中包含列出五位病患信息的四个变量。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  

7.对时间表行进行排序

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

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 

三、代码获取

CSDN后台私信回复“73期”即可。