yaylı ağaç - Splay tree

Bir yayvan ağacı bir olan ikili arama ağacı son erişilen elemanlar tekrar erişime hızlı olan ek özelliğiyle. Gibi kendini dengeleyen ikili arama ağaçları , böyle de yerleştirilmesi, görünüm alma ve kaldırma gibi bir yayvan ağaç gerçekleştirdiği temel işlemler O (log n ) amorti süresi. Rastgele olmayan birçok işlem dizisi için, yayılma ağaçları diğer arama ağaçlarından daha iyi performans gösterir, hatta yeterince rasgele olmayan kalıplar için O(log n )' den daha iyi performans gösterir, üstelik model hakkında önceden bilgi sahibi olmayı gerektirmez. Yayvan ağaç, 1985 yılında Daniel Sleator ve Robert Tarjan tarafından icat edildi .

İkili arama ağacındaki tüm normal işlemler, yayılma adı verilen tek bir temel işlemle birleştirilir . Ağacı belirli bir öğe için yaymak, öğenin ağacın köküne yerleştirilmesi için ağacı yeniden düzenler. Bunu temel arama işlemiyle yapmanın bir yolu, önce söz konusu öğe için standart bir ikili ağaç araması yapmak ve ardından öğeyi en üste getirmek için belirli bir biçimde ağaç döndürmeleri kullanmaktır . Alternatif olarak, yukarıdan aşağıya bir algoritma, aramayı ve ağaç yeniden düzenlemesini tek bir aşamada birleştirebilir.

Avantajlar

Bir yayılma ağacı için iyi performans, kendi kendini optimize etmesine bağlıdır, çünkü sık erişilen düğümler, daha hızlı erişilebilecekleri köke daha yakın hareket eder. En kötü durum yüksekliği – pek olası olmasa da – O( n ) olup, ortalama O(log n )'dir. Kök yakınında sık kullanılan düğümlere sahip olmak, birçok pratik uygulama için bir avantajdır (ayrıca referansın bulunduğu yere bakın ) ve özellikle önbellekleri ve çöp toplama algoritmalarını uygulamak için kullanışlıdır .

Avantajlar şunları içerir:

• Karşılaştırılabilir performans: Ortalama durum performansı, diğer ağaçlar kadar verimlidir.
• Küçük bellek ayak izi: Yayılan ağaçların herhangi bir muhasebe verisi depolamasına gerek yoktur.

Dezavantajları

Yaylı ağaçların en önemli dezavantajı, eğimli ağaçların yüksekliğinin doğrusal olabilmesidir. Örneğin, tüm n öğelerine azalan sırayla erişildikten sonra durum böyle olacaktır . Bir ağacın yüksekliği, en kötü durum erişim süresine karşılık geldiğinden, bu, tek bir işlemin gerçek maliyetinin yüksek olabileceği anlamına gelir. Ancak bu en kötü durumun amorti edilmiş erişim maliyeti logaritmiktir, O(log n ). Ayrıca, rastgele bir değişken kullanılarak beklenen erişim maliyeti O(log n ) değerine düşürülebilir .

Yayılma ağaçlarının temsili, onlara 'salt okunur' bir şekilde (yani, bulma işlemleriyle) erişilse bile değişebilir . Bu, çok iş parçacıklı bir ortamda bu tür yayılma ağaçlarının kullanımını karmaşıklaştırır. Özellikle, birden fazla iş parçacığının aynı anda bulma işlemlerini gerçekleştirmesine izin veriliyorsa ekstra yönetim gerekir . Bu aynı zamanda onları tamamen işlevsel programlamada genel kullanım için uygun hale getirmez, ancak orada bile öncelik sıralarını uygulamak için sınırlı şekillerde kullanılabilirler.

Erişim deseni Son olarak, bir rasgele, ek meyletme havai az dinamik alternatiflere kıyasla maliyetinde önemli bir sabit faktörü ekler.

Operasyonlar

yayılma

Bir x düğümüne erişildiğinde, onu köke taşımak için x üzerinde bir yayma işlemi gerçekleştirilir . Bir yayma işlemi gerçekleştirmek için , her biri x'i köke yaklaştıran bir dizi yayma adımı gerçekleştiririz . Her erişimden sonra ilgilenilen düğüm üzerinde bir yayma işlemi gerçekleştirerek, son erişilen düğümler kökün yakınında tutulur ve ağaç kabaca dengede kalır, böylece istenen amorti edilmiş zaman sınırlarını elde ederiz.

Her belirli adım üç faktöre bağlıdır:

• İster x onun üst düğüm, sol veya sağ çocuğudur p ,
• p'nin kök olup olmadığı ve değilse
• olup s sol veya sağ çocuk onun ana, g ( grandparent x).

Dizi için hatırlamak önemlidir gg ( Büyük-büyükbaba herhangi yayvan ameliyattan sonra x şimdi noktasına x). Eğer gg null, o zaman tabii ki şimdi köküdür ve bu şekilde güncellenmelidir x.

Her biri iki simetrik varyanta sahip olan üç tür yayılma adımı vardır: sol ve sağ el. Kısa olması için, her tür için bu ikisinden yalnızca biri gösterilmiştir. (Aşağıdaki şemalarda, daireler ilgilenilen düğümleri ve üçgenler rastgele büyüklükteki alt ağaçları gösterir.) Üç tür yayılım adımı şunlardır:

Zig adımı: bu adım, p kök olduğunda yapılır . Ağaç, x ve p arasındaki kenarda döndürülür . Parite sorunuyla başa çıkmak için zig adımları vardır, yalnızca bir yayma işleminde son adım olarak ve yalnızca işlemin başında x tek derinliğe sahip olduğunda yapılacaktır .

Zig-zig adımı: bu adım, p kök olmadığında ve x ve p'nin ikisi de sağ çocuklar veya ikisi de sol çocuklar olduğunda yapılır. Aşağıdaki resim, x ve p'nin her ikisinin de kalan çocuklar olduğu durumu göstermektedir. Ağaç birleştirme kenarı üzerinde döndürülür p ile kendi üst g , daha sonra birleştirme kenarı üzerinde döndürülmüş x ile p . Yayılma ağaçlarının tanıtılmasından önce Allen ve Munro tarafından tanıtılan kökten döndürme yönteminden yaylı ağaçları ayıran tek şeyin zig-zig adımları olduğuna dikkat edin .

Zig-zag adımı: bu adım, p kök olmadığında ve x sağ çocuk olduğunda ve p sol çocuk olduğunda veya tam tersi olduğunda yapılır. Ağaç, p ve x arasındaki kenarda döndürülür ve ardından x ve g arasındaki sonuçtaki kenarda döndürülür .

Katılmak

S'nin tüm öğeleri T'nin öğelerinden daha küçük olacak şekilde iki S ve T ağacı verildiğinde, bunları tek bir ağaca birleştirmek için aşağıdaki adımlar kullanılabilir:

• S'deki en büyük öğeyi göster. Şimdi bu öğe S'nin kökünde ve boş bir sağ alt öğeye sahip.
• Yeni kökün sağ alt öğesini T olarak ayarlayın.

Bölmek

Bir ağaç ve bir x öğesi verildiğinde , iki yeni ağaç döndürün: biri x'ten küçük veya ona eşit tüm öğeleri, diğeri ise x'ten büyük tüm öğeleri içerir . Bu, aşağıdaki şekilde yapılabilir:

• yay x . Şimdi köktedir, yani solundaki ağaç x'ten küçük tüm öğeleri içerir ve sağındaki ağaç x'ten büyük tüm öğeleri içerir .
• Sağ alt ağacı ağacın geri kalanından ayırın.

sokma

Bir yayılma ağacına bir x değeri eklemek için :

• Normal bir ikili arama ağacında olduğu gibi x'i ekleyin .
• bir öğe eklendiğinde, bir yayma gerçekleştirilir.
• Sonuç olarak, yeni eklenen x düğümü ağacın kökü olur.

Alternatif olarak:

• Ağacı x değerinde iki alt ağaca bölmek için bölme işlemini kullanın : S ve T.
• Hangi yeni bir ağaç oluşturmak x köküdür, S sol alt ağaç ve T sağ alt ağaçtır.

silme

x düğümünü silmek için ikili arama ağacıyla aynı yöntemi kullanın:

• Eğer x iki çocuğu var:
  • Değerini, sol alt ağacının en sağdaki düğümü (sıralı öncülü) veya sağ alt ağacının en soldaki düğümü (sıralı halefi) ile değiştirin.
  • Bunun yerine o düğümü kaldırın.

Bu şekilde silme, 0 veya 1 çocuklu bir düğümü kaldırma sorununa indirgenir. İkili arama ağacından farklı olarak, silme işleminden sonra bir yayılma ağacında, kaldırılan düğümün üst öğesini ağacın tepesine yayıyoruz.

Alternatif olarak:

• Silinecek düğüm ilk önce gösterilir, yani ağacın köküne getirilir ve ardından silinir. ağacı iki alt ağaçla bırakır.
• İki alt ağaç daha sonra bir "birleştirme" işlemi kullanılarak birleştirilir.

Uygulama ve varyantlar

Yayılma, yukarıda bahsedildiği gibi, bir düğümün erişim yolu üzerinden ikinci bir aşağıdan yukarıya geçiş sırasında gerçekleştirilir. İlk geçiş sırasında erişim yolunu ikinci geçiş sırasında kullanmak üzere kaydetmek mümkündür, ancak bu erişim işlemi sırasında fazladan alan gerektirir. Diğer bir alternatif, erişim işlemleri sırasında fazladan alan ihtiyacını ortadan kaldıran ancak bu işaretçileri güncelleme ihtiyacı nedeniyle genel zaman verimliliğini azaltabilecek her düğümde bir üst işaretçi tutmaktır.

Kullanılabilecek başka bir yöntem, ikinci bir geçiş yapmak yerine, erişim yolundan aşağı inerken ağacı yeniden yapılandırabileceğimiz argümanına dayanmaktadır. Bu yukarıdan aşağıya yayma rutini üç grup düğüm kullanır - sol ağaç, sağ ağaç ve orta ağaç. İlk ikisi, sırasıyla mevcut öğeden daha küçük veya daha büyük olduğu bilinen orijinal ağacın tüm öğelerini içerir. Orta ağaç, geçerli düğümde köklenen alt ağaçtan oluşur. Bu üç küme, görüntüleme işlemlerini kontrol altında tutarken erişim yolunda güncellenir. Diğer bir yöntem olan yarı gösterim, tüm işlemlerde yapılan yeniden yapılandırma miktarını azaltmak için zig-zig durumunu değiştirir.

Aşağıda, ağaçtaki her bir düğümü temsil etmek için işaretçiler kullanan, C++'da bir yayılım ağaçları uygulaması vardır. Bu uygulama aşağıdan yukarıya yayılma versiyonuna dayanır ve bir yayılma ağacında ikinci silme yöntemini kullanır. Ayrıca, yukarıdaki tanım aksine, bu C ++ sürüm yok değil buluntular üzerindeki ağaç Şevli - eklemeler ve silmeler ve bulmak operasyon sadece kompleks bir yapıya sahiptir, bu nedenle, doğrusal zaman karmaşıklığı vardır.

#include <functional>

#ifndef SPLAY_TREE
#define SPLAY_TREE

template<typename T, typename Comp = std::less<T>>
class splay_tree {
private:
  Comp comp;
  unsigned long p_size;
  
  struct node {
    node *left, *right;
    node *parent;
    T key;
    node(const T& init = T()) : left(nullptr), right(nullptr), parent(nullptr), key(init) { }
    ~node() {

    }
  } *root;
  
  void left_rotate(node *x) {
    node *y = x->right;
    if (y) {
      x->right = y->left;
      if (y->left) y->left->parent = x;
      y->parent = x->parent;
    }
    
    if (!x->parent) root = y;
    else if (x == x->parent->left) x->parent->left = y;
    else x->parent->right = y;
    if (y) y->left = x;
    x->parent = y;
  }
  
  void right_rotate(node *x) {
    node *y = x->left;
    if (y) {
      x->left = y->right;
      if (y->right) y->right->parent = x;
      y->parent = x->parent;
    }
    if (!x->parent) root = y;
    else if (x == x->parent->left) x->parent->left = y;
    else x->parent->right = y;
    if (y) y->right = x;
    x->parent = y;
  }
  
  void splay(node *x) {
    while (x->parent) {
      if (!x->parent->parent) {
        if (x->parent->left == x) right_rotate(x->parent);
        else left_rotate(x->parent);
      } else if (x->parent->left == x && x->parent->parent->left == x->parent) {
        right_rotate(x->parent->parent);
        right_rotate(x->parent);
      } else if (x->parent->right == x && x->parent->parent->right == x->parent) {
        left_rotate(x->parent->parent);
        left_rotate(x->parent);
      } else if (x->parent->left == x && x->parent->parent->right == x->parent) {
        right_rotate(x->parent);
        left_rotate(x->parent);
      } else {
        left_rotate(x->parent);
        right_rotate(x->parent);
      }
    }
  }
  
  void replace(node *u, node *v) {
    if (!u->parent) root = v;
    else if (u == u->parent->left) u->parent->left = v;
    else u->parent->right = v;
    if (v) v->parent = u->parent;
  }
  
  node* subtree_minimum(node *u) {
    while (u->left) u = u->left;
    return u;
  }
  
  node* subtree_maximum(node *u) {
    while (u->right) u = u->right;
    return u;
  }
public:
  splay_tree() : root(nullptr), p_size(0) { }
  
  void insert(const T &key) {
    node *z = root;
    node *p = nullptr;
    
    while (z) {
      p = z;
      if (comp(z->key, key)) z = z->right;
      else z = z->left;
    }
    
    z = new node(key);
    z->parent = p;
    
    if (!p) root = z;
    else if (comp(p->key, z->key)) p->right = z;
    else p->left = z;
    
    splay(z);
    p_size++;
  }
  
  node* find(const T &key) {
    node *z = root;
    while (z) {
      if (comp(z->key, key)) z = z->right;
      else if (comp(key, z->key)) z = z->left;
      else return z;
    }
    return nullptr;
  }
        
  void erase(const T &key) {
    node *z = find(key);
    if (!z) return;
    
    splay(z);
    
    if (!z->left) replace(z, z->right);
    else if (!z->right) replace(z, z->left);
    else {
      node *y = subtree_minimum(z->right);
      if (y->parent != z) {
        replace(y, y->right);
        y->right = z->right;
        y->right->parent = y;
      }
      replace(z, y);
      y->left = z->left;
      y->left->parent = y;
    }
    
    delete z;
    p_size--;
  }

/* //the alternative implementation
    void erase(const T &key) {
        node *z = find(key);
        if (!z) return;
        
        splay(z);
        
        node *s = z->left;
        node *t = z->right;
        delete z;
        
        node *sMax = NULL;
        if (s) {
            s->parent = NULL;
            sMax = subtree_maximum(s);
            splay(sMax);
            root = sMax;
        }
        if (t) {
            if (s)
                sMax->right = t;
            else
                root = t;
            t->parent = sMax;
        }
        
        p_size--;
    }
*/
  
  const T& minimum() { return subtree_minimum(root)->key; }
  const T& maximum() { return subtree_maximum(root)->key; }
  
  bool empty() const { return root == nullptr; }
  unsigned long size() const { return p_size; }
};

#endif // SPLAY_TREE

analiz

Statik yayılma ağaçlarının basit bir amortize analizi , potansiyel yöntemi kullanılarak gerçekleştirilebilir . Tanımlamak:

• boyutu ( r ) = Düğüm kökü alt ağaç düğüm sayısı r (dahil r ).
• rank( r ) = log ₂ (boyut( r )).
• Φ = ağaçtaki tüm düğümlerin sıralarının toplamı.

Φ, dengeli olmayan ağaçlar için yüksek ve dengeli ağaçlar için düşük olma eğiliminde olacaktır.

Potansiyel yöntemini uygulamak için önce ΔΦ'yi hesaplarız: bir yayma işleminin neden olduğu potansiyel değişikliği. Her vakayı ayrı ayrı kontrol ediyoruz. İşlemden sonra sıra fonksiyonunu derece ile belirtin. x, p ve g, döndürme işleminden etkilenen düğümlerdir (yukarıdaki şekillere bakın).

Zig adım

ΔΦ	= sıra′( p ) − sıra( p ) + sıra′( x ) − sıra( x )	[sadece p ve x sıraları değiştirdiğinden beri]
	= sıra′( p ) − sıra( x )	[sıradan'( x )=sıra( p )]
	≤ sıra′( x ) − sıra( x )	[dereceden beri′( p )<rank′( x )]

Zig-zig adımı

ΔΦ	= sıra′( g ) − sıra( g ) + sıra′( p ) − sıra( p ) + sıra′( x ) − sıra( x )
	= sıra′( g ) + sıra′( p ) − sıra( p ) − sıra( x )	[derece′(x)=sıra(g)'den beri]
	≤ sıra′( g ) + sıra′( x ) − 2 sıra( x )	[rank( x )<rank( p ) ve rank′( x )>rank′( p ) 'den beri ]
	≤ 3(rank′( x )−rank( x )) − 2	[günlük fonksiyonunun içbükeyliğinden dolayı]

Zig-zag adımı

ΔΦ	= sıra′( g ) − sıra( g ) + sıra′( p ) − sıra( p ) + sıra′( x ) − sıra( x )
	≤ sıra′( g ) + sıra′( p ) − 2 sıra( x )	[sıra′( x )=sıra( g ) ve rütbe( x )<sıra( p )]
	≤ 3(rank′( x )−rank( x )) − 2	[günlük fonksiyonunun içbükeyliğinden dolayı]

Herhangi bir işlemin itfa edilmiş maliyeti ΔΦ artı fiili maliyettir. Herhangi bir zig-zig veya zig-zag işleminin gerçek maliyeti, yapılacak iki dönüş olduğundan 2'dir. Buradan:

amortize edilmiş ücret	= maliyet + ΔΦ
	≤ 3(rank′( x )−rank( x ))

Tüm görüntüleme işlemi üzerinden toplandığında , bu, O(log n ) olan 3(rank(root)−rank( x ))'e teleskop yapar . Zig işlemi amorti edilmiş maliyeti 1 ekler, ancak bu tür en fazla bir işlem vardır.

Şimdi biliyoruz ki, bir dizi m işlem için toplam itfa süresi :

${\displaystyle T_{\mathrm {amorti edilmiş} }(m)=O(m\log n)}$

Amortisman zamanından gerçek zamana gitmek için, herhangi bir işlem yapılmadan önceki ilk durumdan (Φ _i ) tüm işlemler tamamlandıktan sonraki son duruma (Φ _f ) potansiyeldeki azalmayı eklemeliyiz .

${\displaystyle \Phi _{i}-\Phi _{f}=\sum _{x}{\mathrm {derece} _{i}(x)-\mathrm {derece} _{f}(x)} =O(n\log n)}$

burada son eşitsizlik, her x düğümü için minimum sıranın 0 ve maksimum sıranın log( n ) olması gerçeğinden gelir .

Şimdi nihayet gerçek zamanı sınırlayabiliriz:

${\displaystyle T_{\mathrm {gerçek} }(m)=O(m\log n+n\log n)}$

Ağırlıklı analiz

Yukarıdaki analiz aşağıdaki şekilde genelleştirilebilir.

• Her düğüme r bir ağırlık w ( r ) atayın .
• Boyutu (tanımlama r ) = Düğüm kökü alt ağaç düğüm ağırlıklarının toplamı r (dahil r ).
• rank( r ) ve Φ'yi tam olarak yukarıdaki gibi tanımlayın .

Aynı analiz geçerlidir ve bir yayma işleminin itfa edilmiş maliyeti yine şudur:

${\displaystyle \mathrm {rank} (kök)-\mathrm {rank} (x)=O(\log {W}-\log {w(x)})=O\left(\log {\frac {W) }{w(x)}}\sağ)}$

burada W tüm ağırlıkların toplamıdır.

İlk potansiyelden nihai potansiyele düşüş aşağıdakilerle sınırlıdır:

${\displaystyle \Phi _{i}-\Phi _{f}\leq \sum _{x\ağaçta}{\log {\frac {W}{w(x)}}}}$

herhangi bir tek düğümün maksimum boyutu W ve minimumu w(x) olduğundan .

Dolayısıyla gerçek zaman şu şekilde sınırlandırılır:

${\displaystyle O\left(\sum _{x\sırasıyla}{\log {\frac {W}{w(x)}}}+\sum _{x\in tree}{\log {\frac { W}{w(x)}}}\sağ)}$

performans teoremleri

Bir dizi performans için en kötü durum çalışma zamanı ile ilgili çeşitli teoremi ve Konjektürü vardır S ve m ihtiva eden bir şevli ağacında erişimler n elemanları.

Dinamik optimallik varsayımı

Yayvan ağaçlar için kanıtlanmış performans garantilerine ek olarak, orijinal Sleator ve Tarjan kağıdından büyük ilgi gören kanıtlanmamış bir varsayım var. Bu varsayım, dinamik optimallik varsayımı olarak bilinir ve temel olarak, yayılma ağaçlarının, sabit bir faktöre kadar herhangi bir diğer ikili arama ağacı algoritması kadar iyi performans gösterdiğini iddia eder.

Dinamik Eniyilik Sanısı: Izin bir öğe erişen herhangi ikili arama ağacı algoritması olmak üzere kökünden yolunu geçerek bir maliyetle ve bu erişimler dönme başına 1 bir maliyetle ağacındaki herhangi rotasyonlar yapabilir arasında. Erişim sırasını gerçekleştirmenin maliyeti olsun . O zaman bir yayılma ağacının aynı erişimleri gerçekleştirmesinin maliyeti .${\görüntüleme stili A}$${\görüntüleme stili x}$${\görüntüleme stili x}$${\displaystyle d(x)+1}$${\görüntüleme stili A(S)}$${\görüntüleme stili A}$${\görüntüleme stili S}$${\ Displaystyle O[n+A(S)]}$

Dinamik optimallik varsayımının kanıtlanmamış birkaç sonucu vardır:

Geçiş Varsayımı: Aynı öğeleri içeren iki yaylı ağaç olsun ve olsun . Ön sıradaki öğeleri ziyaret ederek elde edilen sıra olsun (yani, derinlik ilk arama sırasında). Adımları gerçekleştirerek toplam maliyeti üzerinde erişimlerin IS .${\görüntüleme stili T_{1}}$${\ Displaystyle T_{2}}$${\görüntüleme stili S}$${\ Displaystyle T_{2}}$${\görüntüleme stili S}$${\görüntüleme stili T_{1}}$${\görüntüleme stili O(n)}$

Deque Conjecture: İki uçlu kuyruk işlemleri dizisi olsun (push, pop, inject, eject). O zaman bir yaylı ağaçta performans göstermenin maliyeti .${\görüntüleme stili S}$${\görüntüleme stili m}$ ${\görüntüleme stili S}$${\görüntüleme stili O(m+n)}$

Bölünmüş Varsayım: Yayılma ağacının öğelerinin herhangi bir permütasyonu olsun . Sonra sırayla elemanları silme maliyeti olduğunu .${\görüntüleme stili S}$${\görüntüleme stili S}$${\görüntüleme stili O(n)}$

Varyantlar

Yeniden yapılandırma işlemlerinin sayısını azaltmak için, yayılmayı , bir elemanın sadece köke doğru yarıya kadar yayıldığı yarı yayılma ile değiştirmek mümkündür .

Yeniden yapılandırmayı azaltmanın başka bir yolu, tam yayılım yapmaktır, ancak bu, yalnızca bazı erişim işlemlerinde - yalnızca erişim yolu bir eşikten daha uzun olduğunda veya yalnızca ilk m erişim işlemlerinde.

Ayrıca bakınız

• parmak ağacı
• Bağlantı/kes ağacı
• günah keçisi ağacı
• Fermuar (veri yapısı)
• Ağaçlar
• Ağaç döndürme
• AVL ağacı
• B ağacı
• T ağacı
• Veri yapılarının listesi
• Iacono'nun çalışma seti yapısı
• İkili arama ağaçlarının geometrisi
• Splaysort , yayılma ağaçlarını kullanan bir sıralama algoritması
• Treap

Notlar

Referanslar

• Albers, Susanne; Karpinski, Marek (28 Şubat 2002). "Rastgele Yayılan Ağaçlar: Teorik ve Deneysel Sonuçlar" (PDF) . Bilgi İşlem Mektupları . 81 (4): 213–221. doi : 10.1016/s0020-0190(01)00230-7 .

• Allen, Brian; Munro, Ian (Ekim 1978). "Kendini organize eden ikili arama ağaçları". ACM Dergisi . 25 (4): 526–535. doi : 10.1145/322092.322094 . S2CID  15967344 .

• Brinkmann, Gunnar; Degraer, Ocak; De Loof, Karel (Ocak 2009). "Sevilmeyen bir çocuğun rehabilitasyonu: yarı yayılma" (PDF) . Yazılım—Uygulama ve Deneyim . 39 (1): 33–45. CiteSeerX  10.1.1.84.790 . doi : 10.1002/spe.v39:1 . hdl : 11382/102133 . Sonuçlar, yayma ile aynı makalede tanıtılan yarı yayılmanın, hemen hemen tüm olası koşullar altında yayılmadan daha iyi performans gösterdiğini göstermektedir. Bu, normal yayılımın uygulanacağı tüm uygulamalar için yarı yayılmayı iyi bir alternatif haline getirir. Yarı yayılma nispeten bilinmezken ve çok daha az çalışılırken yayılmanın neden bu kadar belirgin hale geldiğini anlamak zor.

• Cole, Richard; Mishra, Bud; Schmidt, Jeanette; Siegel, Alan (Ocak 2000). "Splay Trees için Dinamik Parmak Tahmini Üzerine. Bölüm I: Splay Sorting log n-Block Sequences". SIAM Journal on Computing . 30 (1): 1-43. CiteSeerX  10.1.1.36.4558 . doi : 10.1137/s0097539797326988 .

• Cole, Richard (Ocak 2000). "Splay Trees için Dinamik Parmak Tahmini Üzerine. Bölüm II: Kanıt". SIAM Journal on Computing . 30 (1): 44–85. CiteSeerX  10.1.1.36.2713 . doi : 10.1137/S009753979732699X .

• Elmasry, Amr (Nisan 2004), "Splay tree için sıralı erişim teoremi ve Deque varsayımı" , Theoretical Computer Science , 314 (3): 459–466, doi : 10.1016/j.tcs.2004.01.019

• Goodrich, Michael; Tamassia, Roberto; Goldwasser, Michael (2014). Java'da Veri Yapıları ve Algoritmalar (6 ed.). Wiley. P. 506. ISBN 978-1-118-77133-4.

• Knuth, Donald (1997). Bilgisayar Programlama Sanatı . 3: Sıralama ve Arama (3. baskı). Addison-Wesley. P. 478. ISBN 0-201-89685-0.

• Lucas, Joan M. (1991). "Splay Trees Rekabetçiliği Üzerine: Birlik-Bul Problemiyle İlişkiler". Çevrimiçi Algoritmalar: Bir DIMACS Çalıştayının Bildirileri, 11-13 Şubat 1991 . Ayrık Matematik ve Teorik Bilgisayar Bilimi Serisi. 7 . Ayrık Matematik ve Teorik Bilgisayar Bilimleri Merkezi . s. 95–124. ISBN'si 0-8218-7111-0.

• Pettie, Seth (2008), "Splay Trees, Davenport-Schinzel Dizileri ve Deque Tahmini" (PDF) , Proc. 19. ACM-SIAM Ayrık Algoritmalar Sempozyumu , 0707 : 1115–1124, arXiv : 0707.2160 , Bibcode : 2007arXiv0707.2160P

• Sleator, Daniel D. ; Tarjan, Robert E. (1985). "Kendinden Ayarlı İkili Arama Ağaçları" (PDF) . ACM Dergisi . 32 (3): 652-686. doi : 10.1145/3828.3835 . S2CID  1165848 .

• Sundar, Rajamani (1992). "Yayılma algoritması için Deque varsayımı Üzerine". Kombinatorika . 12 (1): 95–124. doi : 10.1007/BF01191208 . S2CID  27422556 .

• Tarjan, Robert E. (1985). "Yayılma ağaçlarında sıralı erişim doğrusal zaman alır". Kombinatorika . 5 (4): 367-378. doi : 10.1007/BF02579253 . S2CID  34757821 .

Dış bağlantılar

• NIST'in Algoritmalar ve Veri Yapıları Sözlüğü: Splay Tree
• C ve Java'daki Uygulamalar (Daniel Sleator tarafından)
• Ağaç görselleştirmelerini yaymak için işaretçiler
• Splay ağaçlarının hızlı ve verimli uygulanması
• Yukarıdan Aşağıya Yayılma Ağacı Java uygulaması
• Fermuar Ağaçları