Sabit bir yığın var mı?

Aşağıdaki işlemleri destekleyen bir öncelik sırası veri yapısı var mı?

• Insert (x, p) : p önceliği olan yeni bir x kaydı ekleyin
• StableExtractMin () : Kaydı asgari önceliğe döndürerek ekleme sırasına göre bağları koparın .

Böylece, Eklemek (a, 1), Eklemek (b, 2), Eklemek (c, 1), Eklemek (d, 2), bir StableExtractMin's dizisi a, sonra c, sonra b, d olur.

Belli bir kullanabilir bir çift depolayarak öncelikli kuyruk veri yapısı , gerçek öncelikli olarak, ama yok veri yapıları ilgilendiğim olmayan stabil bir sıralama için benzer şekilde, açık bir şekilde yerleştirme süreleri (veya ekleme sırası) depolamak .$(p, time)$

Eşdeğer (?): fazladan boşluk gerektirmeyen sağlam bir yığın sürümü var mı ?$\Omega(n)$

Bently-Saxe yöntemi oldukça doğal ve istikrarlı bir öncelik sırası verir.

Verilerinizi dizileri halinde . boyutuna sahip . Her bir dizi ayrıca bir sayacını da korur . dizi girişleri veri içerir.A i 2 i c i A i [ c i ] , … , A i [ 2 i - 1 $A_0,\ldots,A_k$$A_i$$2^i$$c_i$$A_i[c_i],\ldots,A_i[2^i-1]$

Her , tüm elemanlar, daha yakın zamanda eklenmiştir ve her elementinin içindeki değerler, eski elemanların daha yeni elemanların önüne konmasıyla bağların değere göre sıralanmıştır. Bunun, ve ve bu sıralamayı koruyabileceğimiz anlamına geldiğine dikkat edin . (Birleştirme sırasında bağ olması durumunda, öğeyi .)A i A i + 1 A i A i A i + 1 A i + $i$$A_i$$A_{i+1}$$A_i$$A_i$$A_{i+1}$$A_{i+1}$

değerini eklemek için , 0 öğe içerdiği en küçük bulun, ve öğelerini birleştirin , bunu ve uygun şekilde ayarlayın.ben bir $x$$i$$A_i$ x A i c 0 , … , c $A_0,\ldots,A_{i-1}$$x$$A_i$$c_0,\ldots,c_i$

Min çıkarmak için, büyük indeksi bulmak ilk eleman bu tür tüm minimum ve artım .A i [ c i ] i c $i$$A_i[c_i]$$i$$c_i$

Standart argümana göre, bu işlem başına itfa süresi verir ve yukarıda açıklanan sıralama nedeniyle kararlıdır.$O(\log n)$

Bir yerleştirme ve çıkarma dizisi için , bu dizi girişini (boş dizileri saklamayın) artı defter tutma verisi kelimelerini kullanır. Bu, Mihai'nin sorunun versiyonuna cevap vermiyor, ancak istikrarlı kısıtlamanın fazla yer kaplamasını gerektirmediğini gösteriyor. Özellikle, hiçbir olduğunu gösterir gerekli ekstra alan üzerinde düşürmek bağlı.n O ( log n ) Ω ( n $n$$n$$O(\log n)$$\Omega(n)$

Güncelleme: Rolf Fagerberg biz null adlı saklayabilir halinde (veri olmayan) değerleri, daha sonra bütün bu veri yapısı büyüklüğü bir diziye paketlenebilir işaret , burada şimdiye kadar eklemeler sayısıdır.$n$$n$

Öncelikle, dizisini bu sıraya göre (önce , ardından boş değilse ). Bunun yapısı, şimdiye kadar eklenen elementlerin sayısı olan ikili gösterimi ile tamamen kodlanmıştır . İkili gösterimi durumunda pozisyonunda bir 1 sahiptir , daha sonra işgal edecek , dizi konumu, aksi takdirde herhangi bir dizi konumları işgal edecektir.A $A_k,\ldots,A_0$$A_k$ n n i A i 2 $A_{k-1}$$n$$n$$i$$A_i$$2^i$

Diziyi eklerken, ve uzunluğu 1 artar ve mevcut yerinde birleştirme algoritmaları kullanarak artı yeni öğeyi birleştirebiliriz.A 0 , … , A $n$$A_0,\ldots,A_i$

Şimdi, null değerlerini kullandığımız yer sayaçlarından kurtulmaktır . Gelen , biz, ardından takip eden değeri saklamak kalan ardından boş değerler, değerleri. Extract-min sırasında inceleyerek zamanında çıkartılacak değeri hala bulabiliriz . Bu değeri bulduğumuzda ı null ayarladık ve sonra boş olmayan ilk değerini ve ve nin almak için üzerinde ikili arama yapın .A i c i 2 i - c i - 1 O ( log n ) A 0 [ 0 ] , … , A k [ 0 ] A i [ 0 ] A i [ 0 ] A i A i [ c i ] A i [ 0 ] A i [ c i$c_i$$A_i$$c_i$$2^i-c_i-1$$O(\log n)$$A_0[0],\ldots,A_k[0]$$A_i[0]$$A_i[0]$$A_i$$A_i[c_i]$$A_i[0]$$A_i[c_i]$

Sonuç: Tüm yapı, uzunluğu her ekleme ile artan bir dizi ve ekleme sayısını sayan bir sayaç, uygulanabilir.$n$

Kısıtlarınızın ne olduğundan emin değilim; aşağıdakiler uygun mu? Verileri, örtüklü bir ikili ağaç (ikili bir yığın gibi) olarak yorumladığımız bir dizide, ancak veri öğelerini iç düğümlerinden ziyade ağacın alt seviyesinden saklayın. Ağacın her bir iç düğümü, iki çocuktan kopyalanan değerlerden daha küçük depolar; Bağlar olursa, soldaki çocuğu kopyalayın.

Minimumunu bulmak için ağacın köküne bakın.

Bir öğeyi silmek için silinmiş olarak işaretleyin (tembel silme) ve ağacı yukarı doğru kaldırın (silinen öğenin bir kopyasını tutan kök yolundaki her düğüm, diğer çocuğun bir kopyasıyla değiştirilmelidir). Silinen öğelerin sayısını koruyun ve eğer tüm öğelerin bir kesimi çok büyük olursa, o zaman alt seviyedeki öğelerin sırasını koruyarak yapıyı yeniden oluşturun - yeniden oluşturma doğrusal zaman alır; işlem karmaşıklığı.

Bir öğe eklemek için, ağacın alt satırındaki bir sonraki boş konuma ekleyin ve kökü yolunu güncelleyin. Veya, alt satır doluysa, ağacın boyutunu iki katına çıkarın (yine bir amortisman argümanı ile; standart bir ikili yığın dizisini aştığında bu bölümün yeniden oluşturulması gerekmesinden farklı olmadığına dikkat edin).

Bu, Mihai'nin sorunun daha katı versiyonuna bir cevap değil, çünkü gerçek bir silme işleminin alan maliyetini göz ardı etsek bile, gerçek bir gizli veri yapısının iki katı kadar bellek kullanıyor.

Aşağıdaki, sorununuzun geçerli bir yorumudur:

N tuşlarını, A [1..N] dizisinde, destekleyebileceğiniz herhangi bir yardımcı bilginin olmadığı bir yerde saklamanız gerekir: * insert tuşu * delete min.

Örtük veri yapılarının, bazı öğelerin yerel sıralamasında bit kodlama hilesi oynadığı göz önüne alındığında, bu oldukça zor görünmektedir. Burada birden fazla erkek eşitse, sıraları korunmalıdır, bu yüzden böyle numaralar mümkün değildir.

İlginç.

Kısa cevap: Yapamazsın.

Biraz daha uzun cevap:

$\Omega(n)$$\Omega(n)$

$addr(X) < addr(Y)$

Yanlış lapa lapa sözde-matematiğe çok uzun cevap:

Not: İkinci bölümün son kısmı da belirtildiği gibi kabataslakdır. Eğer bir matematikçi daha iyi bir sürüm sunabilseydi, minnettar olurdum.

$P$

$(a,1) < (a,2)$$(a,1) = (a,1)$$(a,1)$$(b,1)$

$X < Y$$X$$Y$

$(?,1)$$?$

• $X - log_2(P)$$2^X$
• $P$

$X - log_2(P)$$O(n)$$n$

Şimdi, her bir bellek "hücresi" bize ne kadar bilgi veriyor?

• $W$$W$
• $X$

$P \geq 1$$X - log_2(P) < X$

Bu yüzden, tüm bilgilerimizi saklamak için iki seçeneğimiz var:

• Ekleme siparişini adrese ve veri yükünü bellekte saklayın.
• Her iki hafızada saklayın ve adresi başka bir kullanım için boş bırakın.

Açıkçası, israfı önlemek için ilk çözümü kullanacağız.

Şimdi işlemler için. Sanırım sahip olmak istersin:

• $Insert(task, priority)$$O(log n)$
• $StableExtractMin()$$O(log n)$

$StableExtractMin()$

Gerçekten çok genel bir algoritma şöyle devam eder:

1. $O(log n)$
2. $O(log n)$
3. İade etmek.

$0(1)$$O(1)$$O(1)$

$O(log n)$$2^(X - log_2(P))$

$X - log_2(P)$$O(log n)$$O(log n)$

$O(log n)$

$O(log n)$$X - log_2(P)$

$O(log n)$

$X - log_2(P)$$O(log n)$

Ekleme algoritması genellikle sadece bu bilginin bir kısmını güncellemeli, hızlı performans göstermesi daha pahalıya mal olacağını sanmıyorum.

$X - log_2(P)$

• $X - log_2(P)$
• $P$
• $X - log_2(P)$

$\Omega(n)$

Öncelik sıranızı dengeli bir ikili ağaç (popüler bir seçim) olarak uygularsanız, o zaman ağaca bir öğe eklediğinizde, eşit önceliğe sahip herhangi bir öğenin soluna eklendiğinden emin olmanız gerekir.
Bu şekilde, ekleme sırası ağacın yapısında kodlanır.

Bunun mümkün olduğunu sanmıyorum

somut vaka:

       x
    x    x
  x  x  1  x
1  x  

Tüm x> 1 ile min öbek

yığınlama sonunda böyle bir seçim yapacaktır

       x
    1    1
  x  x  x  x
x  x  

Şimdi hangi 1 kök yaymak için?