Sorting and Related Functions

sort!(v; alg::Algorithm=defalg(v), lt=isless, by=identity, rev::Bool=false, order::Ordering=Forward)

قم بترتيب المتجه v في المكان. يتم استخدام خوارزمية مستقرة بشكل افتراضي: يتم الحفاظ على ترتيب العناصر التي تقارن على أنها متساوية. يمكن اختيار خوارزمية محددة عبر الكلمة الرئيسية alg (انظر خوارزميات الترتيب للاطلاع على الخوارزميات المتاحة).

يتم تحويل العناصر أولاً باستخدام الدالة by ثم يتم مقارنتها وفقًا إما للدالة lt أو الترتيب order. أخيرًا، يتم عكس الترتيب الناتج إذا كان rev=true (هذا يحافظ على الاستقرار الأمامي: العناصر التي تقارن على أنها متساوية لا يتم عكسها). التطبيق الحالي يطبق تحويل by قبل كل مقارنة بدلاً من مرة واحدة لكل عنصر.

تمرير lt غير isless مع order غير Base.Order.Forward أو Base.Order.Reverse غير مسموح به، وإلا فإن جميع الخيارات مستقلة ويمكن استخدامها معًا في جميع التركيبات الممكنة. لاحظ أن order يمكن أن يتضمن أيضًا تحويل "by"، وفي هذه الحالة يتم تطبيقه بعد ذلك المحدد بواسطة الكلمة الرئيسية by. لمزيد من المعلومات حول قيم order، انظر الوثائق حول ترتيبات بديلة.

تُعرّف العلاقات بين عنصرين كما يلي (مع تبادل "أقل" و "أكبر" عندما يكون rev=true):

• x أقل من y إذا كانت lt(by(x), by(y)) (أو Base.Order.lt(order, by(x), by(y))) تعطي true.
• x أكبر من y إذا كانت y أقل من x.
• x و y متساويان إذا لم يكن أي منهما أقل من الآخر ("غير قابل للمقارنة" يُستخدم أحيانًا كمرادف لـ "متساوي").

نتيجة sort! مرتبة بالمعنى الذي يكون فيه كل عنصر أكبر من أو متساوي مع العنصر السابق.

يجب أن تعرف دالة lt ترتيبًا ضعيفًا صارمًا، أي يجب أن تكون

• غير انعكاسية: lt(x, x) دائمًا تعطي false,
• غير متناظرة: إذا كانت lt(x, y) تعطي true فإن lt(y, x) تعطي false,
• متعدية: 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 ولكن ≤ ليست كذلك: إنها تنتهك عدم الانعكاسية. بالنسبة لقيم Float64 حتى < غير صالحة لأنها تنتهك الشرط الرابع: 1.0 و NaN متساويان وكذلك NaN و 2.0 لكن 1.0 و 2.0 ليسا متساويين.

انظر أيضًا sort، sortperm، sortslices، partialsort!، partialsortperm، issorted، searchsorted، insorted، Base.Order.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)) # نفس الشيء مثل sort(0:3, by=abs(x->x-2))
4-element Vector{Int64}:
 2
 1
 3
 0

julia> sort([2, NaN, 1, NaN, 3]) # ترتيب صحيح مع lt الافتراضي=isless
5-element Vector{Float64}:
   1.0
   2.0
   3.0
 NaN
 NaN

julia> sort([2, NaN, 1, NaN, 3], lt=<) # ترتيب خاطئ بسبب lt غير صالح. هذا السلوك غير محدد.
5-element Vector{Float64}:
   2.0
 NaN
   1.0
 NaN
   3.0

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

قم بترتيب المصفوفة متعددة الأبعاد A على طول البعد dims. راجع النسخة أحادية البعد من sort! لوصف الوسائط الممكنة.

لترتيب شرائح من مصفوفة، ارجع إلى sortslices.

أمثلة

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::Algorithm=defalg(v), lt=isless, by=identity, rev::Bool=false, order::Ordering=Forward)

نسخة من sort! التي تعيد نسخة مرتبة من v دون تعديل v نفسه.

أمثلة

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

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

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

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

قم بترتيب مصفوفة متعددة الأبعاد A على طول البعد المعطى. انظر sort! لوصف الوسائط الممكنة.

لترتيب شرائح من مصفوفة، راجع sortslices.

أمثلة

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

sortperm(A; alg::Algorithm=DEFAULT_UNSTABLE, lt=isless, by=identity, rev::Bool=false, order::Ordering=Forward, [dims::Integer])

إرجاع متجه أو مصفوفة ترتيب I التي تضع A[I] في ترتيب مرتب على البعد المحدد. إذا كانت A تحتوي على أكثر من بعد واحد، يجب تحديد وسيط الكلمة dims. يتم تحديد الترتيب باستخدام نفس الكلمات الرئيسية مثل sort!. من المضمون أن يكون الترتيب مستقراً حتى لو كانت خوارزمية الفرز غير مستقرة: ستظهر مؤشرات العناصر المتساوية بترتيب تصاعدي.

انظر أيضًا sortperm!، partialsortperm، invperm، indexin. لفرز شرائح من مصفوفة، راجع sortslices.

أمثلة

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

ترتيب الإدراج

استخدم خوارزمية ترتيب الإدراج.

يقوم ترتيب الإدراج بعبور المجموعة عنصرًا تلو الآخر، مدخلاً كل عنصر في موقعه الصحيح والمرتّب في متجه الإخراج.

الخصائص:

• مستقر: يحافظ على ترتيب العناصر التي تقارن بالتساوي

(مثل "a" و "A" في ترتيب الحروف الذي يتجاهل الحالة).

• في المكان في الذاكرة.
• أداء تربيعي في عدد العناصر التي يجب ترتيبها:

إنه مناسب تمامًا للمجموعات الصغيرة ولكن لا ينبغي استخدامه للمجموعات الكبيرة.

MergeSort

تشير إلى أن دالة الفرز يجب أن تستخدم خوارزمية فرز الدمج. يقوم فرز الدمج بتقسيم المجموعة إلى مجموعات فرعية ودمجها بشكل متكرر، مع فرز كل مجموعة فرعية في كل خطوة، حتى يتم إعادة دمج المجموعة بالكامل في شكل مرتب.

الخصائص:

• مستقر: يحافظ على ترتيب العناصر التي تقارن بالتساوي (مثل "a" و "A" في فرز الحروف التي تتجاهل الحالة).
• ليس في المكان في الذاكرة.
• استراتيجية فرز تقسيم-و-غزو.
• أداء جيد للمجموعات الكبيرة ولكن عادةً ليس سريعًا مثل QuickSort.

QuickSort

تشير إلى أن دالة الفرز يجب أن تستخدم خوارزمية الفرز السريع، والتي ليست مستقرة.

الخصائص:

• ليست مستقرة: لا تحافظ على ترتيب العناصر التي تقارن بالتساوي (مثل "a" و "A" في فرز الحروف التي تتجاهل الحالة).
• في المكان في الذاكرة.
• تقسيم وغزو: استراتيجية الفرز مشابهة لـ MergeSort.
• أداء جيد للمجموعات الكبيرة.

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

يشير إلى أن وظيفة الفرز يجب أن تستخدم خوارزمية الفرز السريع الجزئي. PartialQuickSort(k) تشبه QuickSort، ولكنها مطلوبة فقط للعثور على العناصر التي ستنتهي في v[k] إذا تم فرز v بالكامل.

الخصائص:

• غير مستقرة: لا تحافظ على ترتيب العناصر التي تقارن بالتساوي (على سبيل المثال "a" و "A" في فرز الحروف الذي يتجاهل الحالة).
• في المكان في الذاكرة.
• تقسيم وغزو: استراتيجية الفرز مشابهة لـ MergeSort.

لاحظ أن PartialQuickSort(k) لا تقوم بالضرورة بفرز المصفوفة بالكامل. على سبيل المثال،

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::Algorithm=DEFAULT_UNSTABLE, lt=isless, by=identity, rev::Bool=false, order::Ordering=Forward, [dims::Integer])

مثل sortperm، ولكن يقبل متجه أو مصفوفة فهرس مُعدة مسبقًا ix بنفس axes مثل A. يتم تهيئة ix لتحتوي على القيم LinearIndices(A).

!!! تحذير قد يكون السلوك غير متوقع عندما يتشارك أي وسيط معدل الذاكرة مع أي وسيط آخر.

!!! توافق "جوليا 1.9" تتطلب الطريقة التي تقبل dims على الأقل جوليا 1.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. يجب أن تكون الوسيطة الرئيسية المطلوبة dims إما عدد صحيح أو مجموعة من الأعداد الصحيحة. تحدد الأبعاد التي يتم ترتيب الشرائح عليها.

على سبيل المثال، إذا كانت A مصفوفة، فإن dims=1 ستقوم بترتيب الصفوف، و dims=2 ستقوم بترتيب الأعمدة. لاحظ أن دالة المقارنة الافتراضية على الشرائح أحادية البعد ترتب بشكل قوامي.

للحصول على الوسائط الرئيسية المتبقية، راجع وثائق sort!.

أمثلة

julia> sortslices([7 3 5; -1 6 4; 9 -2 8], dims=1) # ترتيب الصفوف
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) # ترتيب الأعمدة
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

الأبعاد الأعلى

يمتد sortslices بشكل طبيعي إلى الأبعاد الأعلى. على سبيل المثال، إذا كانت A مصفوفة 2x2x2، فإن sortslices(A, dims=3) ستقوم بترتيب الشرائح ضمن البعد الثالث، مع تمرير الشرائح 2x2 A[:, :, 1] و A[:, :, 2] إلى دالة المقارنة. لاحظ أنه بينما لا يوجد ترتيب افتراضي على الشرائح ذات الأبعاد الأعلى، يمكنك استخدام الوسيطة الرئيسية by أو lt لتحديد مثل هذا الترتيب.

إذا كانت dims مجموعة، فإن ترتيب الأبعاد في dims يكون ذا صلة ويحدد الترتيب الخطي للشرائح. على سبيل المثال، إذا كانت A ثلاثية الأبعاد و dims هي (1, 2)، فإن ترتيبات البعدين الأولين يتم إعادة ترتيبها بحيث يتم ترتيب الشرائح (من البعد الثالث المتبقي). إذا كانت dims هي (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'

julia> sortslices(reshape([5; 4; 3; 2; 1], (1,1,5)), dims=3, by=x->x[1,1])
1×1×5 Array{Int64, 3}:
[:, :, 1] =
 1

[:, :, 2] =
 2

[:, :, 3] =
 3

[:, :, 4] =
 4

[:, :, 5] =
 5

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

اختبر ما إذا كانت مجموعة مرتبة. تعدل الكلمات الرئيسية ما يعتبر ترتيبًا مرتبًا، كما هو موضح في وثائق sort!.

أمثلة

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 مرتّبًا وفقًا للترتيب المحدد بواسطة الكلمات الرئيسية. راجع sort! لمعنى الكلمات الرئيسية وتعريف التكافؤ. لاحظ أن دالة by تُطبق على القيمة المُبحَث عنها x وكذلك القيم في v.

يتم العثور على النطاق عمومًا باستخدام البحث الثنائي، ولكن هناك تطبيقات محسّنة لبعض المدخلات.

انظر أيضًا: searchsortedfirst، sort!، insorted، findall.

أمثلة

julia> searchsorted([1, 2, 4, 5, 5, 7], 4) # تطابق فردي
3:3

julia> searchsorted([1, 2, 4, 5, 5, 7], 5) # تطابقات متعددة
4:5

julia> searchsorted([1, 2, 4, 5, 5, 7], 3) # لا يوجد تطابق، إدراج في المنتصف
3:2

julia> searchsorted([1, 2, 4, 5, 5, 7], 9) # لا يوجد تطابق، إدراج في النهاية
7:6

julia> searchsorted([1, 2, 4, 5, 5, 7], 0) # لا يوجد تطابق، إدراج في البداية
1:0

julia> searchsorted([1=>"one", 2=>"two", 2=>"two", 4=>"four"], 2=>"two", by=first) # مقارنة مفاتيح الأزواج
2:3

searchsortedfirst(v, x; by=identity, lt=isless, rev=false)

إرجاع فهرس أول قيمة في v التي لا يتم ترتيبها قبل x. إذا كانت جميع القيم في v مرتبة قبل x، إرجع lastindex(v) + 1.

يجب أن يكون المتجه v مرتبا وفقًا للترتيب المحدد بواسطة الكلمات الرئيسية. إن إدراج x في الفهرس المعاد سيحافظ على الترتيب المرتب. راجع sort! لمعنى واستخدام الكلمات الرئيسية. لاحظ أن دالة by تُطبق على القيمة المُبحَث عنها x وكذلك القيم في v.

يتم العثور على الفهرس عادةً باستخدام البحث الثنائي، ولكن هناك تنفيذات محسّنة لبعض المدخلات.

انظر أيضًا: searchsortedlast، searchsorted، findfirst.

أمثلة

julia> searchsortedfirst([1, 2, 4, 5, 5, 7], 4) # تطابق واحد
3

julia> searchsortedfirst([1, 2, 4, 5, 5, 7], 5) # تطابقات متعددة
4

julia> searchsortedfirst([1, 2, 4, 5, 5, 7], 3) # لا يوجد تطابق، إدراج في المنتصف
3

julia> searchsortedfirst([1, 2, 4, 5, 5, 7], 9) # لا يوجد تطابق، إدراج في النهاية
7

julia> searchsortedfirst([1, 2, 4, 5, 5, 7], 0) # لا يوجد تطابق، إدراج في البداية
1

julia> searchsortedfirst([1=>"one", 2=>"two", 4=>"four"], 3=>"three", by=first) # مقارنة مفاتيح الأزواج
3

searchsortedlast(v, x; by=identity, lt=isless, rev=false)

إرجاع فهرس آخر قيمة في v التي لا تُرتب بعد x. إذا كانت جميع القيم في v مرتبة بعد x، إرجع firstindex(v) - 1.

يجب أن يكون المتجه v مرتبا وفقًا للترتيب المحدد بواسطة الكلمات الرئيسية. إن إدراج x مباشرة بعد الفهرس المعاد سيحافظ على الترتيب المرتب. راجع sort! لمعنى واستخدام الكلمات الرئيسية. لاحظ أن دالة by تُطبق على القيمة المُبحَث عنها x وكذلك القيم في v.

يتم العثور على الفهرس عمومًا باستخدام البحث الثنائي، ولكن هناك تطبيقات محسّنة لبعض المدخلات.

أمثلة

julia> searchsortedlast([1, 2, 4, 5, 5, 7], 4) # تطابق واحد
3

julia> searchsortedlast([1, 2, 4, 5, 5, 7], 5) # تطابقات متعددة
5

julia> searchsortedlast([1, 2, 4, 5, 5, 7], 3) # لا تطابق، إدراج في المنتصف
2

julia> searchsortedlast([1, 2, 4, 5, 5, 7], 9) # لا تطابق، إدراج في النهاية
6

julia> searchsortedlast([1, 2, 4, 5, 5, 7], 0) # لا تطابق، إدراج في البداية
0

julia> searchsortedlast([1=>"one", 2=>"two", 4=>"four"], 3=>"three", by=first) # مقارنة مفاتيح الأزواج
2

insorted(x, v; by=identity, lt=isless, rev=false) -> Bool

حدد ما إذا كان المتجه v يحتوي على أي قيمة تعادل x. يجب أن يكون المتجه v مرتبا وفقًا للترتيب المحدد بواسطة الكلمات الرئيسية. راجع sort! لمعنى الكلمات الرئيسية وتعريف التكافؤ. لاحظ أن دالة by تُطبق على القيمة المُبحَث عنها x وكذلك القيم في v.

يتم إجراء الفحص عادةً باستخدام البحث الثنائي، ولكن هناك تنفيذات محسّنة لبعض المدخلات.

انظر أيضًا in.

أمثلة

julia> insorted(4, [1, 2, 4, 5, 5, 7]) # تطابق فردي
true

julia> insorted(5, [1, 2, 4, 5, 5, 7]) # تطابقات متعددة
true

julia> insorted(3, [1, 2, 4, 5, 5, 7]) # لا يوجد تطابق
false

julia> insorted(9, [1, 2, 4, 5, 5, 7]) # لا يوجد تطابق
false

julia> insorted(0, [1, 2, 4, 5, 5, 7]) # لا يوجد تطابق
false

julia> insorted(2=>"TWO", [1=>"one", 2=>"two", 4=>"four"], by=first) # قارن مفاتيح الأزواج
true

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

قم بترتيب المتجه v جزئيًا في المكان بحيث يحدث القيمة عند الفهرس k (أو نطاق القيم المتجاورة إذا كان k نطاقًا) في الموضع الذي ستظهر فيه إذا كانت المصفوفة مرتبة بالكامل. إذا كان k فهرسًا فرديًا، يتم إرجاع تلك القيمة؛ إذا كان k نطاقًا، يتم إرجاع مصفوفة من القيم عند تلك الفهارس. لاحظ أن partialsort! قد لا يرتب المصفوفة المدخلة بالكامل.

لوسائط الكلمات الرئيسية، راجع وثائق sort!.

أمثلة

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)

نسخة من partialsort! التي تقوم بنسخ v قبل فرزها جزئيًا، وبالتالي تعيد نفس الشيء مثل partialsort! ولكن تترك v غير معدلة.

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

إرجاع ترتيب جزئي I من المتجه v، بحيث v[I] يعيد قيم النسخة المرتبة بالكامل من v عند الفهرس k. إذا كان k نطاقًا، يتم إرجاع متجه من الفهارس؛ إذا كان k عددًا صحيحًا، يتم إرجاع فهرس واحد. يتم تحديد الترتيب باستخدام نفس الكلمات الرئيسية مثل sort!. الترتيب مستقر: ستظهر فهارس العناصر المتساوية بترتيب تصاعدي.

هذه الدالة تعادل، لكنها أكثر كفاءة من، استدعاء 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)

مثل partialsortperm، ولكن يقبل متجه فهارس مُخصص مسبقًا ix بنفس حجم v، والذي يُستخدم لتخزين (ترتيب) فهارس v.

يتم تهيئة ix ليحتوي على فهارس v.

(عادةً، ستكون فهارس v هي 1:length(v)، على الرغم من أنه إذا كان لدى v نوع مصفوفة بديل بفهارس غير قائمة على الواحد، مثل OffsetArray، يجب أن تشارك ix تلك الفهارس نفسها)

عند العودة، يُضمن أن تحتوي ix على الفهارس k في مواقعها المرتبة، بحيث

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

قيمة الإرجاع هي العنصر k من ix إذا كان k عددًا صحيحًا، أو عرض في ix إذا كان 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.Order.Ordering

نوع مجرد يمثل ترتيب ضعيف صارم على مجموعة من العناصر. انظر إلى sort! لمزيد من المعلومات.

استخدم Base.Order.lt لمقارنة عنصرين وفقًا للترتيب.

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

اختبر ما إذا كان a أقل من b وفقًا للترتيب o.

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

قم بإنشاء كائن Ordering من نفس المعاملات المستخدمة في sort!. يتم أولاً تحويل العناصر بواسطة الدالة by (التي قد تكون identity) ثم يتم مقارنتها وفقًا إما للدالة lt أو ترتيب موجود order. يجب أن تكون lt هي isless أو دالة تلتزم بنفس القواعد مثل معلمة lt في sort!. أخيرًا، يتم عكس الترتيب الناتج إذا كان rev=true.

لا يُسمح بتمرير lt غير isless مع order غير Base.Order.Forward أو Base.Order.Reverse، وإلا فإن جميع الخيارات مستقلة ويمكن استخدامها معًا في جميع التركيبات الممكنة.

Base.Order.Forward

الترتيب الافتراضي وفقًا لـ isless.

ReverseOrdering(fwd::Ordering=Forward)

غلاف يعكس ترتيب.

بالنسبة لـ Ordering معين o، فإن ما يلي ينطبق على جميع a، b:

lt(ReverseOrdering(o), a, b) == lt(o, b, a)

Base.Order.Reverse

ترتيب عكسي وفقًا لـ isless.

By(by, order::Ordering=Forward)

Ordering الذي يطبق order على العناصر بعد أن تم تحويلها بواسطة الدالة by.

Lt(lt)

Ordering التي تستدعي lt(a, b) لمقارنة العناصر. يجب أن تلتزم lt بنفس القواعد مثل معلمة lt في sort!.

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

Ordering على مؤشرات data حيث i أقل من j إذا كان data[i] أقل من data[j] وفقًا لـ order. في حالة أن data[i] و data[j] متساويان، يتم مقارنة i و j بالقيمة العددية.