Sorting and Related Functions

Julia, sıralama ve zaten sıralanmış değer dizileriyle etkileşim kurma konusunda kapsamlı ve esnek bir API'ye sahiptir. Varsayılan olarak, Julia makul algoritmalar seçer ve artan sırada sıralar:

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

Ters sıralama da yapabilirsiniz:

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

sort, girdi değişmeden sıralı bir kopya oluşturur. Mevcut bir diziyi değiştirmek için sıralama fonksiyonunun "bang" versiyonunu kullanın:

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

julia> sort!(a);

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

Diziyi doğrudan sıralamak yerine, dizinin sıralı hale gelmesini sağlayan dizinin indekslerinin bir permütasyonunu hesaplayabilirsiniz:

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

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

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

Diziler, değerlerinin keyfi bir dönüşümüne göre sıralanabilir:

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

Ya da bir dönüşümle ters sırayla:

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

Gerekirse, sıralama algoritması seçilebilir:

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

Tüm sıralama ve düzen ile ilgili işlevler, işlenmesi gereken değerler üzerinde bir strict weak order tanımlayan bir "küçüktür" ilişkisine dayanır. isless işlevi varsayılan olarak çağrılır, ancak ilişki lt anahtar kelimesi aracılığıyla belirtilebilir; bu, iki dizi elemanı alan ve yalnızca ilk argümanın ikinci argümandan "küçük" olması durumunda true döndüren bir işlevdir. Daha fazla bilgi için sort! ve Alternate Orderings'ya bakın.

Sorting Functions

Base.sort! — Function

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

Vektörü v yerinde sıralar. Varsayılan olarak kararlı bir algoritma kullanılır: eşit karşılaştırılan elemanların sıralaması korunur. Belirli bir algoritma alg anahtar kelimesi aracılığıyla seçilebilir (mevcut algoritmalar için Sıralama Algoritmaları bölümüne bakın).

Elemanlar önce by fonksiyonu ile dönüştürülür ve ardından ya lt fonksiyonu ya da order sıralamasına göre karşılaştırılır. Son olarak, sonuç sıralaması rev=true ise tersine çevrilir (bu, ileri stabiliteyi korur: eşit karşılaştırılan elemanlar tersine çevrilmez). Mevcut uygulama, her karşılaştırmadan önce by dönüşümünü uygular, her eleman için bir kez değil.

isless dışındaki bir lt fonksiyonu ile Base.Order.Forward veya Base.Order.Reverse dışındaki bir order kullanmak yasaktır, aksi takdirde tüm seçenekler bağımsızdır ve tüm olası kombinasyonlarda birlikte kullanılabilir. order ayrıca bir "by" dönüşümü de içerebilir; bu durumda, by anahtar kelimesi ile tanımlanan dönüşümden sonra uygulanır. order değerleri hakkında daha fazla bilgi için Alternatif Sıralamalar belgesine bakın.

İki eleman arasındaki ilişkiler aşağıdaki gibi tanımlanır (bu durumda "daha az" ve "daha fazla" rev=true olduğunda değiştirilir):

x, y'den daha azdır eğer lt(by(x), by(y)) (veya Base.Order.lt(order, by(x), by(y))) doğruysa.
x, y'den daha fazladır eğer y, x'den daha azdır.
x ve y eşdeğerdir eğer hiçbiri diğerinden daha az değildir ("karşılaştırılamaz" bazen "eşdeğer" için bir eşanlamlı olarak kullanılır).

sort! fonksiyonunun sonucu, her elemanın bir öncekinden daha büyük veya eşdeğer olduğu anlamında sıralıdır.

lt fonksiyonu katı bir zayıf sıralama tanımlamalıdır, yani:

irrefleksif olmalıdır: lt(x, x) her zaman false döner,
asimetrik olmalıdır: eğer lt(x, y) doğruysa, o zaman lt(y, x) yanlış olmalıdır,
geçişli olmalıdır: lt(x, y) && lt(y, z) ise lt(x, z)'yi gerektirir,
eşdeğerlikte geçişli olmalıdır: !lt(x, y) && !lt(y, x) ve !lt(y, z) && !lt(z, y) birlikte !lt(x, z) && !lt(z, x)'yi gerektirir. Kısacası: eğer x ve y eşdeğer ve y ve z eşdeğer ise, o zaman x ve z de eşdeğer olmalıdır.

Örneğin, < Int değerleri için geçerli bir lt fonksiyonudur, ancak ≤ değildir: irrefleksifliği ihlal eder. Float64 değerleri için, < bile geçerli değildir çünkü dördüncü koşulu ihlal eder: 1.0 ve NaN eşdeğerdir ve NaN ve 2.0 da öyle, ancak 1.0 ve 2.0 eşdeğer değildir.

Ayrıca sort, sortperm, sortslices, partialsort!, partialsortperm, issorted, searchsorted, insorted, Base.Order.ord belgelerine de bakın.

Örnekler

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)) # same as sort(0:3, by=abs(x->x-2))
4-element Vector{Int64}:
 2
 1
 3
 0

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

Sorting Functions

Order-Related Functions

Sorting Algorithms

Alternate Orderings