认识一下MATLAB 的 sort ( Sort array elements )函数

mytomorrow

sort
Sort array elements
' c8 R) ~- M" Q6 Q
Syntax

6 p+ `2 N" j( w- z) KB = sort(A)
% G) r) y' Z& c5 H) R
B = sort(A,dim)
! x+ V$ v/ B5 V* M/ E$ o$ B
B = sort(___,direction)
! K4 n2 P0 t4 N/ L
B = sort(___,Name,Value)
4 a& N& [1 ^% X" U0 N2 G
[B,I] = sort(___)
" ?3 w; R& t# V% z) |+ O# B
1 `5 \7 U( o3 F# ZDescription

B = sort（A）按升序对A的元素进行排序。

• 如果A是向量，则sort（A）对向量元素进行排序。
• 如果A是矩阵，则sort（A）将A的列视为向量并对每列进行排序。
• 如果A是多维数组，则sort（A）沿着第一个数组维度操作，其大小不等于1，将元素视为向量。
  ) m) ^3 C  V+ N' O! D1 T4 M, ?* h8 Q

9 ~1 R: z( w  w' SB = sort（A，dim）返回沿着维度dim的A的排序元素。 例如，如果A是矩阵，则sort（A，2）对每行的元素进行排序。

' s: L3 N, m" j) rB = sort（___，direction）使用任何先前的语法按方向指定的顺序返回A的已排序元素。 'ascend'表示升序（默认值），'descend'表示降序。

B = sort（___，Name，Value）指定用于排序的附加参数。 例如，sort（A，'ComparisonMethod'，'abs'）按大小对A的元素进行排序。

[B，I] = sort（___）还返回任何先前语法的索引向量的集合。 I 与 A 的大小相同，并描述了沿着排序维度将A元素排列到B中。 例如，如果A是向量，则B = A（I）。

意思就是B是排序后的向量，而I是B中的元素在A中的索引。


' ]: r$ S( I" d6 L  T. G3 _: u( K7 y操作的维度，指定为正整数标量。 如果未指定任何值，则默认值为第一个大小不等于1的数组维度。

# k8 F1 v5 E: ]

• 考虑矩阵A. sort（A，1）对A列中的元素进行排序。
  

8 `- s. Z$ f- u' a- |1 W

• sort（A，2）对A行中的元素进行排序。
  / E3 P2 F! ^! s

) N2 [6 F4 M3 f
6 B" l- _0 `; t
* A7 w& B/ l: D9 |# {% ^如果dim大于ndims（A），则返回A. 当A是cell数组时，不支持dim，即，sort仅沿大小不等于1的第一个数组维度操作。
7 C1 M% |1 T/ R* J# ~% `2 K" s

% U) J5 V0 h  {, Z1 p. {. d下面举例说明：
' {5 E- E1 F6 y
  P& m4 o1 J  c# e$ Z7 `Sort Vector in Ascending Order

创建一个行向量，并升序排序：
1 e* a7 c) m  A
! s3 d/ W4 v$ j  ^8 |+ b" G& E& a0 v

• clc
• clear
• close all
• A = [9 0 -7 5 3 8 -10 4 2];
• B = sort(A)
  - S" h. d0 R% t3 w: T* S7 Y

; ^) X4 m3 r6 z2 u3 N" i8 f
, z+ H, g- S3 J& ]结果：
8 K& N- F0 ^8 C* {& k* i( T) l
* L4 C" S1 @- V( j0 ]+ G; UB =
3 W- z2 N# j# m1 Y2 i' R4 N. D
   -10    -7     0     2     3     4     5     8     9


' D! [! \% o: [( u- c8 C+ USort Matrix Rows in Ascending Order

" [1 s4 L# c8 `$ d; G5 d创建一个矩阵，并对其每列降序排序：
+ O* Y7 h& X' \/ Y: }6 m; a8 Q
  u. l- W9 W6 ?/ _6 a1 x, ?; k

• clc
• clear
• close all
• % Create a matrix and sort its columns in descending order.
• 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')
  

  
0 n. \- r2 s5 x9 t, z
+ c- Z7 V7 R7 x! Z+ C5 M/ z6 X4 \" }结果：
5 F; m6 P0 H8 c  Y  v
A =

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


B =

    10     3    11     8
+ y5 E! k  K; R! M% f     6     1     9     3
, g& I* A3 g, E4 Q# I7 a% F3 B6 K     2    -9     8     0
     1   -12     4    -2


$ e, g; [1 @( Q9 h" U) GSort String Array

& d, P# g% l/ C: `
" D% v" S! o* q' o/ P对字符串数组排序：

从R2016b开始，您可以使用字符串函数创建字符串数组，并使用sort函数对它们进行排序。 根据Unicode®字典顺序对字符串数组的每列中的字符串进行排序。
7 Y4 E( g1 B2 e$ s

• clc
• clear
• close all
• % Starting in R2016b, you can create string arrays using the string function,
• % and sort them using the sort function. Sort strings in each column of a string array according to Unicode® dictionary order.
• A = string({'Smith','Burns';...
•     'Jones','Matthews';...
•     'Peterson','Adams'});
• B = sort(A)
• % B = 3x2 string array
• %     "Jones"       "Adams"
• %     " Peterson"    "Burns"
• %     "Smith"       "Matthews"
• %
• % Sort the strings in each row.
• B = sort(A,2)
• % B = 3x2 string array
• %     "Burns"    "Smith"
• %     "Jones"    "Matthews"
• %     "Adams"    "Peterson"
• %
  

   
结果：
' N: n% f8 g) J# y6 U# G1 V! ]+ h
) x5 L. {9 }$ l, t* z* B9 S( jB =
! `, ?. F# z* E* ^* \
3 r) h1 D0 [% Z! M  3×2 string 数组
  u2 E+ O$ L3 y# g' g+ u5 s
. ^5 m! L" `- N; v    "Jones"       "Adams"   
8 l5 A7 {) w2 X3 O    "P eterson"    "Burns"   
+ H* X% C' i8 f. R1 j. a- `' W    "Smith"       "Matthews"
. C+ g5 E3 `9 z! P, A" G

+ G. F* C! w3 r  D. U1 oB =

  3×2 string 数组

; p# h- b; s) B: Y/ q' p1 s    "Burns"    "Smith"   
    "Jones"    "Matthews"
    "Adams"    "P eterson"
% N( K2 i+ a7 d5 R

Sort and Index datetime Array

* ]/ e) _4 V' r* U5 Y
- M+ F  O# K: x9 B* o排序并获得datetime数组的索引

• clc
• clear
• close all
• % 创建一个datetime值数组，并按升序对其进行排序，即从最早的日历日期到最晚的日历日期。
• 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
• % I = 3×1
• %
• %      3
• %      1
• %      2
• % B lists the sorted dates and I contains the corresponding indices of A.
• % Access the sorted elements from the original array directly by using the index array I.
• A(I)
• % ans = 3x1 datetime array
• %    1992-01-12
• %    2012-12-22
• %    2063-04-05
  : D3 f! I* p( _( P2 O# ^, _

      
. h7 s! l/ _( e" u, n2 f/ F结果：

A =

  3×1 datetime 数组

   2012-12-22
+ z4 F8 ?. V+ f! X0 q1 k   2063-04-05
   1992-01-12

2 ~- r/ y/ \/ P) t1 u
7 L5 U1 }8 @: h+ J4 {! ^, OB =

7 e6 Z# K  \! x1 K( E( R6 P( ~) }! l/ G  3×1 datetime 数组

   1992-01-12
- M. s9 V; O3 I2 J. f0 |' K   2012-12-22
   2063-04-05
" I  m5 g- L6 [. C' Q3 e1 Z

& l' q- G$ [5 ?$ U  V# u, z3 f6 V% fI =
8 y/ g# S. S# t. J5 s2 p3 O; a
     3
     1
' r! r/ _0 M+ J! O; [     2


ans =
3 k2 d) r% V, k. Q
: U. Z& w: c6 X4 Z  3×1 datetime 数组
# z. n% h4 ^8 A' F( \: I
0 m# Q1 K6 s5 Z3 z! _: A2 I   1992-01-12
   2012-12-22
   2063-04-05


$ T" A" C9 D$ M8 \Sort 3-D Array

6 t) P" ?0 d; U9 f

• clc
• clear
• close all
• % Create a 2-by-2-by-2 array and sort its elements in ascending order along the third dimension.
• 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的所有元素。
• B = sort(A(：）)
• % B = 8×1
• %
• %     -1
• %      0
• %      1
• %      2
• %      3
• %      6
• %      9
• %     12
    c/ D) p5 j5 \, M" y) H( {& ?) j

     
; j) @6 X; S) o* A! O% A
Complex Vector

• clc
• clear
• close all
• % Sort the elements of a complex vector by their real parts.
• %对于具有相同实部的元素，sort会根据其虚部来打破关系。
• 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 ⋯
  

  
# Q- p% j: g# E) j: y/ S
4 j3 \$ d3 g$ p# N' s

ExxNEN

谢谢分享