AnyMath 文档

排序和相关功能

Julia有一个广泛而灵活的api，用于排序和与已经排序的值数组交互。 默认情况下，Julia选择合理的算法并按升序排序:

julia> sort([2,3,1])
3-element Vector{Int64}:
 1
 2
 3

您也可以按相反的顺序排序:

julia> sort([2,3,1], rev=true)
3-element Vector{Int64}:
 3
 2
 1

排序 构造一个排序的副本，使其输入保持不变。 使用sort函数的"bang"版本来改变现有数组:

julia> a = [2,3,1];

julia> sort!(a);

julia> a
3-element Vector{Int64}:
 1
 2
 3

您可以计算数组索引的排列，将数组按排序顺序排列，而不是直接对数组进行排序:

julia> v = randn(5)
5-element Vector{Float64}:
  0.297288
  0.382396
 -0.597634
 -0.0104452
 -0.839027

julia> p = sortperm(v)
5-element Vector{Int64}:
 5
 3
 4
 1
 2

julia> v[p]
5-element Vector{Float64}:
 -0.839027
 -0.597634
 -0.0104452
  0.297288
  0.382396

数组可以根据其值的任意转换进行排序:

julia> sort(v, by=abs)
5-element Vector{Float64}:
 -0.0104452
  0.297288
  0.382396
 -0.597634
 -0.839027

或以相反的顺序通过变换:

julia> sort(v, by=abs, rev=true)
5-element Vector{Float64}:
 -0.839027
 -0.597634
  0.382396
  0.297288
 -0.0104452

如果需要，可以选择排序算法:

julia> sort(v, alg=InsertionSort)
5-element Vector{Float64}:
 -0.839027
 -0.597634
 -0.0104452
  0.297288
  0.382396

所有与排序和排序相关的函数都依赖于定义一个"小于"关系https://en.wikipedia.org/wiki/Weak_ordering#Strict_weak_orderings要操作的值上的[严格弱顺序]。 该 无为 默认情况下调用函数，但可以通过 lt 关键字，接受两个数组元素并返回的函数 真的 当且仅当第一个参数"小于"第二个参数。 见 排序！和 备用顺序以获取更多信息。

排序函数

sort!(A; dims::Integer, alg::Base.Sort.Algorithm=Base.Sort.defalg(A), lt=isless, by=identity, rev::Bool=false, order::Base.Order.Ordering=Base.Order.Forward)

对多维数组进行排序 A 沿尺寸 暗淡无光. 请参阅 排序！对于可能的关键字参数的描述。

要对数组的切片进行排序，请参阅 分类表.

兼容性

Julia1.1此功能至少需要Julia1.1。

*例子*

julia> A = [4 3; 1 2]
2×2 Matrix{Int64}:
 4  3
 1  2

julia> sort!(A, dims = 1); A
2×2 Matrix{Int64}:
 1  2
 4  3

julia> sort!(A, dims = 2); A
2×2 Matrix{Int64}:
 1  2
 3  4
sort!(v; alg::Base.Sort.Algorithm=Base.Sort.defalg(v), lt=isless, by=identity, rev::Bool=false, order::Base.Order.Ordering=Base.Order.Forward)

对向量进行排序 v 就位。 默认情况下使用稳定算法：保留比较相等的元素的顺序。 一个特定的算法可以通过选择 阿尔格 关键字（见 排序算法）。

元素首先用函数进行变换 由 然后根据任一函数进行比较 lt 或订购 秩序. 最后，如果出现以下情况，则生成的顺序相反 rev=真 （这保留了前向稳定性：比较相等的元素不会反转）。 当前的实现应用 由 在每次比较之前转换，而不是每个元素一次。

通过一个 lt 除了 无障碍 随着一个 秩序 除了 基地。秩序。前进,前进或 基地。秩序。反向是不允许的，否则所有选项都是独立的，可以在所有可能的组合中一起使用。 请注意 秩序 还可以包括一个"by"转换，在这种情况下，它是在与 由 关键字。 有关更多资料 秩序 值请参阅以下文档 备用顺序。

两个元素之间的关系定义如下（当"更少"和"更大"交换时 rev=真):

* x 小于 y 如果 lt(由(x),由(y)) （或 Base.Order.lt(顺序,按(x),按(y))）产生真。 * x 大于 y 如果 y 小于 x. * x 和 y 如果两者都不小于另一个，则是等价的（"无与伦比"有时用作"等价"的同义词）。

的结果 排序！ 在每个元素大于或等于前一个元素的意义上排序。

该 lt 函数必须定义一个严格的弱顺序，即它必须是

*不可逆转: lt(x,x) 总是收益率 错误, *不对称：如果 长(x,y) 产量 真的 然后 lt(y,x) 产量 错误, *传递性: lt(x,y)&&lt(y,z) 暗示 lt(x,z), *等价的传递性: !lt(x,y)&&!lt(y,x) 和 !lt(y,z)&&!lt(z,y) 一起暗示 !lt(x,z)&&!lt(z,x). 在的话：如果 x 和 y 是等价的和 y 和 z 那么是等价的吗？ x 和 z 必须是等价的。

例如 < 是有效的 lt 功能为 Int型 价值观但 ≤ 不是：它违反了不可逆转性。 为 漂浮64 甚至价值 < 是无效的，因为它违反了第四个条件: 1.0 和 南 是等价的，也是等价的 南 和 2.0 但是 1.0 和 2.0 不是等价的。

请参阅 排序, 鹿sortperm, 分类表, partialsort！, 局部/局部/局部, n.杂种,杂种, 搜索结果, 鹿陇梅insorted, 基地。秩序。ord.

*例子*

julia> v = [3, 1, 2]; sort!(v); v
3-element Vector{Int64}:
 1
 2
 3

julia> v = [3, 1, 2]; sort!(v, rev = true); v
3-element Vector{Int64}:
 3
 2
 1

julia> v = [(1, "c"), (3, "a"), (2, "b")]; sort!(v, by = x -> x[1]); v
3-element Vector{Tuple{Int64, String}}:
 (1, "c")
 (2, "b")
 (3, "a")

julia> v = [(1, "c"), (3, "a"), (2, "b")]; sort!(v, by = x -> x[2]); v
3-element Vector{Tuple{Int64, String}}:
 (3, "a")
 (2, "b")
 (1, "c")

julia> sort(0:3, by=x->x-2, order=Base.Order.By(abs))
4-element Vector{Int64}:
 2
 1
 3
 0

julia> sort(0:3, by=x->x-2, order=Base.Order.By(abs)) == sort(0:3, by=x->abs(x-2))
true

julia> sort([2, NaN, 1, NaN, 3]) # correct sort with default lt=isless
5-element Vector{Float64}:
   1.0
   2.0
   3.0
 NaN
 NaN

julia> sort([2, NaN, 1, NaN, 3], lt=<) # wrong sort due to invalid lt. This behavior is undefined.
5-element Vector{Float64}:
   2.0
 NaN
   1.0
 NaN
   3.0
sort(A; dims::Integer, alg::Base.Sort.Algorithm=Base.Sort.defalg(A), lt=isless, by=identity, rev::Bool=false, order::Base.Order.Ordering=Base.Order.Forward)

对多维数组进行排序 A 沿着给定的维度。 见 排序！对于可能的关键字参数的描述。

要对数组的切片进行排序，请参阅 分类表.

*例子*

julia> A = [4 3; 1 2]
2×2 Matrix{Int64}:
 4  3
 1  2

julia> sort(A, dims = 1)
2×2 Matrix{Int64}:
 1  2
 4  3

julia> sort(A, dims = 2)
2×2 Matrix{Int64}:
 3  4
 1  2
sort(v::Union{AbstractVector, NTuple}; alg::Base.Sort.Algorithm=Base.Sort.defalg(v), lt=isless, by=identity, rev::Bool=false, order::Base.Order.Ordering=Base.Order.Forward)

的变体 排序！返回的排序副本 v 离开 v 本身未经修改。

兼容性

朱莉娅1.12排序 N.婴儿s需要Julia1.12或更高版本。

*例子*

julia> v = [3, 1, 2];

julia> sort(v)
3-element Vector{Int64}:
 1
 2
 3

julia> v
3-element Vector{Int64}:
 3
 1
 2
sortperm(A; alg::Base.Sort.Algorithm=Base.Sort.DEFAULT_UNSTABLE, lt=isless, by=identity, rev::Bool=false, order::Base.Order.Ordering=Base.Order.Forward, [dims::Integer])

返回置换向量或数组 我 这意味着 A[I] 按照给定维度的排序顺序。 如果 A 具有多个维度，则 暗淡无光 必须指定关键字参数。 使用与以下相同的关键字指定顺序 排序！. 即使排序算法不稳定，排列也保证稳定：相等元素的索引将以升序出现。

请参阅 sortperm！, 局部/局部/局部, n.外阴,外阴, 索引,索引. 要对数组的切片进行排序，请参阅 分类表.

兼容性

Julia1.9接受的方法 暗淡无光 至少需要Julia1.9。

*例子*

julia> v = [3, 1, 2];

julia> p = sortperm(v)
3-element Vector{Int64}:
 2
 3
 1

julia> v[p]
3-element Vector{Int64}:
 1
 2
 3

julia> A = [8 7; 5 6]
2×2 Matrix{Int64}:
 8  7
 5  6

julia> sortperm(A, dims = 1)
2×2 Matrix{Int64}:
 2  4
 1  3

julia> sortperm(A, dims = 2)
2×2 Matrix{Int64}:
 3  1
 2  4
InsertionSort

使用插入排序算法。

插入排序一次遍历集合一个元素，将每个元素插入其在输出向量中正确排序的位置。

特征:

*_stable_：保留比较相等的元素的顺序

（例如忽略大小写的字母中的"a"和"A"）。

*_in-place_在内存中。 *_quadratic performance_在要排序的元素数量:

它非常适合小型集合，但不应用于大型集合。

MergeSort

指示排序函数应使用合并排序算法。 归并排序将集合划分为子集合并反复合并，在每个步骤对每个子集进行排序，直到整个集合以排序的形式重新组合。

特征:

*_stable_：保留比较相等的元素的顺序（例如忽略大小写的字母中的"a"和"A"）。 *不在内存中。 *_divide-and-conquer_排序策略。 *_good performance_适用于大型集合，但通常不如 流沙/流沙.

QuickSort

指示排序函数应使用快速排序算法，该算法是_not_稳定的。

特征:

*_not stable_：不保留比较相等的元素的顺序（例如，忽略大小写的字母中的"a"和"A"）。 *_in-place_在内存中。 *_divide-and-conquer_：排序策略类似于 合并/合并. *_good performance_用于大型集合。

PartialQuickSort{T <: Union{Integer,OrdinalRange}}

指示排序函数应使用部分快速排序算法。 PartialQuickSort(ķ) 就像 流沙/流沙，但只需要查找和排序最终会出现的元素 v[k] 是 v 完全排序。

特征:

*_not stable_：不保留比较相等的元素的顺序（例如，忽略大小写的字母中的"a"和"A"）。 *_in-place_在内存中。 *_divide-and-conquer_：排序策略类似于 合并/合并.

请注意 PartialQuickSort(ķ) 不一定对整个数组进行排序。 例如,

julia> x = rand(100);

julia> k = 50:100;

julia> s1 = sort(x; alg=QuickSort);

julia> s2 = sort(x; alg=PartialQuickSort(k));

julia> map(issorted, (s1, s2))
(true, false)

julia> map(x->issorted(x[k]), (s1, s2))
(true, true)

julia> s1[k] == s2[k]
true
sortperm!(ix, A; alg::Base.Sort.Algorithm=Base.Sort.DEFAULT_UNSTABLE, lt=isless, by=identity, rev::Bool=false, order::Base.Order.Ordering=Base.Order.Forward, [dims::Integer])

像 鹿sortperm，但接受预分配的索引向量或数组 九 同 轴心 作为 A. 九 被初始化为包含值 线性元件(A).

当任何突变的参数与任何其他参数共享内存时，警告行为可能是意外的。
兼容性

Julia1.9接受的方法 暗淡无光 至少需要Julia1.9。

*例子*

julia> v = [3, 1, 2]; p = zeros(Int, 3);

julia> sortperm!(p, v); p
3-element Vector{Int64}:
 2
 3
 1

julia> v[p]
3-element Vector{Int64}:
 1
 2
 3

julia> A = [8 7; 5 6]; p = zeros(Int,2, 2);

julia> sortperm!(p, A; dims=1); p
2×2 Matrix{Int64}:
 2  4
 1  3

julia> sortperm!(p, A; dims=2); p
2×2 Matrix{Int64}:
 3  1
 2  4
sortslices(A; dims, alg::Algorithm=DEFAULT_UNSTABLE, lt=isless, by=identity, rev::Bool=false, order::Ordering=Forward)

对数组的切片进行排序 A. 所需的关键字参数 暗淡无光 必须是整数或整数元组。 它指定对切片进行排序的维度。

例如，如果 A 是矩阵, dims=1 将排序行, dims=2 将排序列。 请注意，一维切片上的默认比较函数按字典排序。

有关其余关键字参数，请参阅 排序！.

*例子*

julia> sortslices([7 3 5; -1 6 4; 9 -2 8], dims=1) # Sort rows
3×3 Matrix{Int64}:
 -1   6  4
  7   3  5
  9  -2  8

julia> sortslices([7 3 5; -1 6 4; 9 -2 8], dims=1, lt=(x,y)->isless(x[2],y[2]))
3×3 Matrix{Int64}:
  9  -2  8
  7   3  5
 -1   6  4

julia> sortslices([7 3 5; -1 6 4; 9 -2 8], dims=1, rev=true)
3×3 Matrix{Int64}:
  9  -2  8
  7   3  5
 -1   6  4

julia> sortslices([7 3 5; 6 -1 -4; 9 -2 8], dims=2) # Sort columns
3×3 Matrix{Int64}:
  3   5  7
 -1  -4  6
 -2   8  9

julia> sortslices([7 3 5; 6 -1 -4; 9 -2 8], dims=2, alg=InsertionSort, lt=(x,y)->isless(x[2],y[2]))
3×3 Matrix{Int64}:
  5   3  7
 -4  -1  6
  8  -2  9

julia> sortslices([7 3 5; 6 -1 -4; 9 -2 8], dims=2, rev=true)
3×3 Matrix{Int64}:
 7   5   3
 6  -4  -1
 9   8  -2

*更高的尺寸*

分类表 自然延伸到更高的维度。 例如，如果 A 是一个2x2x2阵列, sortslices（A，dims=3） 将在第3维内对切片进行排序，传递2x2切片 A[:,:,1] 和 A[:,:,2] 到比较函数。 请注意，虽然高维切片上没有默认顺序，但您可以使用 由 或 lt 关键字参数来指定这样的顺序。

如果 暗淡无光 是一个元组，维度的顺序在 暗淡无光 是相关的，并指定切片的线性顺序。 例如，如果 A 是三维的和 暗淡无光 是 (1, 2)，前两个维度的顺序被重新排列，以便（剩余的第三个维度的）切片被排序。 如果 暗淡无光 是 (2, 1) 相反，将采取相同的切片，但结果顺序将是行主要。

*更高维度的例子*

julia> A = [4 3; 2 1 ;;; 'A' 'B'; 'C' 'D']
2×2×2 Array{Any, 3}:
[:, :, 1] =
 4  3
 2  1

[:, :, 2] =
 'A'  'B'
 'C'  'D'

julia> sortslices(A, dims=(1,2))
2×2×2 Array{Any, 3}:
[:, :, 1] =
 1  3
 2  4

[:, :, 2] =
 'D'  'B'
 'C'  'A'

julia> sortslices(A, dims=(2,1))
2×2×2 Array{Any, 3}:
[:, :, 1] =
 1  2
 3  4

[:, :, 2] =
 'D'  'C'
 'B'  'A'

朱莉娅>sortslices（重塑([5; 4; 3; 2; 1], (1,1,5)), dims=3，by=x->x[1,1]）
1×1×5阵列{Int64, 3}:
[:, :, 1] =
 1

[:, :, 2] =
 2

[:, :, 3] =
 3

[:, :, 4] =
 4

[:, :, 5] =
 5

订单相关功能

issorted(v, lt=isless, by=identity, rev::Bool=false, order::Base.Order.Ordering=Base.Order.Forward)

测试集合是否按排序顺序。 关键字修改被认为是排序的顺序，如 排序！文件。

*例子*

julia> issorted([1, 2, 3])
true

julia> issorted([(1, "b"), (2, "a")], by = x -> x[1])
true

julia> issorted([(1, "b"), (2, "a")], by = x -> x[2])
false

julia> issorted([(1, "b"), (2, "a")], by = x -> x[2], rev=true)
true

julia> issorted([1, 2, -2, 3], by=abs)
true
searchsorted(v, x; by=identity, lt=isless, rev=false)

返回指数的范围 v 其中值等效于 x，或位于插入点的空范围，如果 v 不包含等价于 x. 向量 v 必须按照关键字定义的顺序进行排序。 参考 排序！对于关键字的含义和等价的定义。 请注意， 由 函数应用于搜索值 x 以及在值 v.

范围通常使用二进制搜索找到，但对于某些输入有优化的实现。

请参阅: 首先搜索, 排序！, 鹿陇梅insorted, 芬德尔.

*例子*

julia> searchsorted([1, 2, 4, 5, 5, 7], 4) # single match
3:3

julia> searchsorted([1, 2, 4, 5, 5, 7], 5) # multiple matches
4:5

julia> searchsorted([1, 2, 4, 5, 5, 7], 3) # no match, insert in the middle
3:2

julia> searchsorted([1, 2, 4, 5, 5, 7], 9) # no match, insert at end
7:6

julia> searchsorted([1, 2, 4, 5, 5, 7], 0) # no match, insert at start
1:0

julia> searchsorted([1=>"one", 2=>"two", 2=>"two", 4=>"four"], 2=>"two", by=first) # compare the keys of the pairs
2:3
searchsortedfirst(v, x; by=identity, lt=isless, rev=false)

返回第一个值的索引 v 以前没有订购过 x. 如果所有值在 v 之前订购 x，返回 lastindex(v)+1.

向量 v 必须按照关键字定义的顺序进行排序。 插入！荷兰国际集团 x 在返回的索引将保持排序的顺序。 参考 排序！对于关键字的含义和用途。 请注意， 由 函数应用于搜索值 x 以及在值 v.

索引通常使用二进制搜索找到，但对于某些输入有优化的实现。

请参阅: 最后的搜索, 搜索结果, [医芬迪斯特].

*例子*

julia> searchsortedfirst([1, 2, 4, 5, 5, 7], 4) # single match
3

julia> searchsortedfirst([1, 2, 4, 5, 5, 7], 5) # multiple matches
4

julia> searchsortedfirst([1, 2, 4, 5, 5, 7], 3) # no match, insert in the middle
3

julia> searchsortedfirst([1, 2, 4, 5, 5, 7], 9) # no match, insert at end
7

julia> searchsortedfirst([1, 2, 4, 5, 5, 7], 0) # no match, insert at start
1

julia> searchsortedfirst([1=>"one", 2=>"two", 4=>"four"], 3=>"three", by=first) # compare the keys of the pairs
3
searchsortedlast(v, x; by=identity, lt=isless, rev=false)

返回最后一个值的索引 v 那不是在订购后订购的 x. 如果所有值在 v 后订购 x，返回 firstindex(v)-1.

向量 v 必须按照关键字定义的顺序进行排序。 插入！荷兰国际集团 x 紧接着返回的索引将保持排序后的顺序。 参考 排序！对于关键字的含义和用途。 请注意， 由 函数应用于搜索值 x 以及在值 v.

索引通常使用二进制搜索找到，但对于某些输入有优化的实现

*例子*

julia> searchsortedlast([1, 2, 4, 5, 5, 7], 4) # single match
3

julia> searchsortedlast([1, 2, 4, 5, 5, 7], 5) # multiple matches
5

julia> searchsortedlast([1, 2, 4, 5, 5, 7], 3) # no match, insert in the middle
2

julia> searchsortedlast([1, 2, 4, 5, 5, 7], 9) # no match, insert at end
6

julia> searchsortedlast([1, 2, 4, 5, 5, 7], 0) # no match, insert at start
0

julia> searchsortedlast([1=>"one", 2=>"two", 4=>"four"], 3=>"three", by=first) # compare the keys of the pairs
2
insorted(x, v; by=identity, lt=isless, rev=false) -> Bool

确定向量是否 v 包含等效于的任何值 x. 向量 v 必须按照关键字定义的顺序进行排序。 参考 排序！对于关键字的含义和等价的定义。 请注意， 由 函数应用于搜索值 x 以及在值 v.

检查通常使用二进制搜索完成，但对于某些输入有优化的实现。

请参阅 在.

*例子*

julia> insorted(4, [1, 2, 4, 5, 5, 7]) # single match
true

julia> insorted(5, [1, 2, 4, 5, 5, 7]) # multiple matches
true

julia> insorted(3, [1, 2, 4, 5, 5, 7]) # no match
false

julia> insorted(9, [1, 2, 4, 5, 5, 7]) # no match
false

julia> insorted(0, [1, 2, 4, 5, 5, 7]) # no match
false

julia> insorted(2=>"TWO", [1=>"one", 2=>"two", 4=>"four"], by=first) # compare the keys of the pairs
true
兼容性

朱莉娅1.6 [医] 在Julia1.6中添加。

 
partialsort!(v, k; by=identity, lt=isless, rev=false)

对向量进行部分排序 v 到位，以便索引处的值 k （或相邻值的范围，如果 k 是一个范围）发生在数组完全排序时它会出现的位置。 如果 k 是单个索引，则返回该值；如果 k 是一个范围，返回这些索引处的值数组。 请注意 partialsort！ 可能无法对输入数组进行完全排序。

有关关键字参数，请参阅 排序！.

*例子*

julia> a = [1, 2, 4, 3, 4]
5-element Vector{Int64}:
 1
 2
 4
 3
 4

julia> partialsort!(a, 4)
4

julia> a
5-element Vector{Int64}:
 1
 2
 3
 4
 4

julia> a = [1, 2, 4, 3, 4]
5-element Vector{Int64}:
 1
 2
 4
 3
 4

julia> partialsort!(a, 4, rev=true)
2

julia> a
5-element Vector{Int64}:
 4
 4
 3
 2
 1
partialsort(v, k, by=identity, lt=isless, rev=false)

的变体 xref:base/sort.adoc#Base.Sort.partialsort![partialsort！ 那份副本 v 在对其进行部分排序之前，从而返回与 partialsort！ 但离开 v 未修改。

partialsortperm(v, k; by=identity, lt=isless, rev=false)

返回部分置换 我 向量的 v，使 v[I] 返回完全排序版本的值 v 在索引 k. 如果 k 是一个范围，返回一个索引的向量；如果 k 是整数，则返回单个索引。 使用与以下相同的关键字指定顺序 排序！. 排列是稳定的：相等元素的索引将以升序出现。

此函数等效于调用，但比调用更有效 sortperm（。..)[k].

*例子*

julia> v = [3, 1, 2, 1];

julia> v[partialsortperm(v, 1)]
1

julia> p = partialsortperm(v, 1:3)
3-element view(::Vector{Int64}, 1:3) with eltype Int64:
 2
 4
 3

julia> v[p]
3-element Vector{Int64}:
 1
 1
 2
partialsortperm!(ix, v, k; by=identity, lt=isless, rev=false)

像 [医局部]，但接受一个预分配的索引向量 九 大小与 v，用于存储（排列） v.

九 初始化为包含 v.

（通常，指数 v 将是 1:长度(v)，虽然如果 v 具有非基于一的索引的替代数组类型，例如 [医]阵列, 九 必须共享那些相同的指数）

回来后, 九 保证有指数 k 在它们的排序位置，使得

partialsortperm!(ix, v, k);
v[ix[k]] == partialsort(v, k)

返回值为 k第三要素 九 如果 k 是一个整数，或查看到 九 如果 k 是一个范围。

当任何突变的参数与任何其他参数共享内存时，警告行为可能是意外的。

*例子*

julia> v = [3, 1, 2, 1];

julia> ix = Vector{Int}(undef, 4);

julia> partialsortperm!(ix, v, 1)
2

julia> ix = [1:4;];

julia> partialsortperm!(ix, v, 2:3)
2-element view(::Vector{Int64}, 2:3) with eltype Int64:
 4
 3

排序算法

目前有四种排序算法在base Julia中公开可用:

* 插入/插入 * 流沙/流沙 * PartialQuickSort(ķ) * 合并/合并

默认情况下， 排序 函数族使用稳定的排序算法,在大多数输入上是快速的. 确切的算法选择是一个实现细节，以允许未来的性能改进。 目前，混合 N.基数,基数, ScratchQuickSort, 插入,插入，而 计数/计数 根据输入类型、大小和组成使用。 实施细节可能会更改，但目前可在 ??基地。默认值_STABLE 以及那里列出的内部排序算法的文档字符串。

您可以使用 阿尔格 关键字(例如 排序！（v，alg=PartialQuickSort（10：20）））或通过向 基地。排序。脱脩脟茅脕麓陆脱 函数。 例如，https://github.com/JuliaStrings/InlineStrings.jl/blob/v1.3.2/src/InlineStrings.jl#L903[InlineStrings.jl]定义以下方法:

Base.Sort.defalg(::AbstractArray{<:Union{SmallInlineStrings, Missing}}) = InlineStringSort
兼容性

Julia1.9默认排序算法（返回 基地。排序。脱脩脟茅脕麓陆脱）保证自Julia1.9以来保持稳定。 以前的版本在对数值数组进行排序时存在不稳定的边缘情况。

其他命令

默认情况下, 排序, 搜索结果，及相关功能使用 无为比较两个元素，以确定哪个应该先来。 该 xref:base/sort.adoc#Base.Order.Ordering[基地。秩序。订购服务 抽象类型提供了一种在同一组元素上定义交替排序的机制：当调用排序函数时，如 排序！，一个实例 订购服务 可以提供关键字参数 秩序.

的实例 订购服务 通过定义订单 Base.Order.lt函数，它作为一个泛化 无障碍. 此函数在自定义上的行为 订购服务s必须满足a的所有条件https://en.wikipedia.org/wiki/Weak_ordering#Strict_weak_orderings[严格的弱顺序]。 见 排序！有关有效和无效的详细信息和示例 lt 函数。

Base.Order.Ordering

抽象类型，表示某组元素上的严格弱顺序。 见 排序！更多。

使用方法 Base.Order.lt根据排序比较两个元素。

lt(o::Ordering, a, b) -> Bool

测试是否 a 小于 b 根据订购 o.

ord(lt, by, rev::Union{Bool, Nothing}, order::Ordering=Forward)

构建一个 订购服务来自由 排序！. 元素首先由函数变换 由 （可能是 身份认同），然后根据任一函数进行比较 lt 或现有订购 秩序. lt 应该是 无为或服从与所述相同规则的函数 lt 的参数 排序！. 最后，如果出现以下情况，则生成的顺序相反 rev=真.

通过一个 lt 除了 无障碍 随着一个 秩序 除了 基地。秩序。前进,前进或 基地。秩序。反向是不允许的，否则所有选项都是独立的，可以在所有可能的组合中一起使用。

Base.Order.Forward

默认排序根据 无障碍.

ReverseOrdering(fwd::Ordering=Forward)

反转排序的包装器。

对于给定的 订购服务 o，以下内容适用于所有 a, b:

lt(ReverseOrdering(o), a, b) == lt(o, b, a)
Base.Order.Reverse

反向排序根据 无障碍.

By(by, order::Ordering=Forward)

订购服务 哪些适用 秩序 在元素被函数转换后 由.

Lt(lt)

订购服务 这就需要 lt(a,b) 来比较元素。 lt 必须遵守与 lt 的参数 排序！.

Perm(order::Ordering, data::AbstractVector)

订购服务 关于 数据资料 哪里 i 小于 j 如果 数据[i] 小于 数据[j] 根据 秩序. 在这种情况下 数据[i] 和 数据[j] 都是平等的, i 和 j 通过数值进行比较。