**İkili arama ağacı**, verileri organize etmek için kullanılan bir çeşit ikili ağaçtır. İkili ağaçtan temel farkı, verilerin sıralanmış bir şekilde tutulmasıdır, bu sayede ikili arama algoritmasının kullanılmasına imkân verir.

9 elemanlı, yüksekliği 4 ve kökü 8 olan bir ikili arama ağacı
İkili arama ağaçlarında; her düğümün sağ çocuğu kendisinden büyük, sol çocuğu ise kendisinden küçüktür. Bu ağaçlarda çalışan arama algoritması önce kökten başlar, eğer aranan eleman kökten büyükse sağ çocuğa, kökten küçükse sol çocuğa ilerler. Böylece, eleman bulunana yapraklara kadar yinelemeli bir şekilde ilerleme sağlanır.

İşlemler
--------

İkili arama ağacı üzerinde; arama, ekleme, silme işlemleri yapılabilir.

### Arama

Kökten başlanarak arama işlemi yapılır. Eğer aranan eleman o anki düğümden büyükse sağa, küçükse sola ilerlenir. Bu algoritma bir döngü içinde ya da özyinelemeli şekilde uygulanabilir. Python kodu şu şekildedir:

```
def search\_recursively(key, node):
    if node is None or node.key == key:
        return node
    if key < node.key:
        return search\_recursively(key, node.left)
    # key > node.key
    return search\_recursively(key, node.right)

```

```
def search\_iteratively(key, node): 
    current\_node = node
    while current\_node is not None:
        if key == current\_node.key:
            return current\_node
        elif key < current\_node.key:
            current\_node = current\_node.left
        else: # key > current\_node.key:
            current\_node = current\_node.right
    return current\_node

```

### Ekleme

Eleman ekleme işlemi her zaman yapraklara ya da tek çocuğu olan düğümlere yapılır. Bunun için öncelikle eklenecek elemanın konumu bulunmalıdır, konum bulma işlemi arama kısmında olduğu gibi büyükse sağa, küçükse sola ilerle şeklinde yapılır. Bu algoritma da bir döngü içinde ya da özyinelemeli şekilde uygulanabilir. C++ kodu şu şekildedir:

```
Node\* insert(Node\*& root, int key, int value) {
 if (!root) 
 root = new Node(key, value);
 else if (key < root->key)
 root->left = insert(root->left, key, value);
 else // key >= root->key
 root->right = insert(root->right, key, value);
 return root;

```

### Silme

İki çocuğu olan bir düğümün (D) silinmesi. D, E ile yer değiştirilip siliniyor.
Silme işlemi üç başlık altında incelenebilir. Eğer,

* Silinecek düğümün çocuğu yoksa: basitçe düğüm silinir.
* Silinecek düğümün tek çocuğu varsa: düğüm silinir ve tek çocuk silinen düğümün yerine taşınır.
* Silinecek düğümün iki çocuğu varsa: silinecek düğüme D diyelim, D'yi silmeden önce D'den büyük en küçük eleman bulunur (*inorder successor*) buna da E diyelim. E ile D yer değiştirilir ve ardından D silinir.

Bir elemandan büyük en küçük eleman, o elemanın sağ alt ağacının en solundaki elemandır ve bunu bulmak için ekstra metot yazmak gerekir. Bu yüzden, silme algoritması ekleme ve arama algoritmalarına göre daha uzundur. Python kodu şu şekildedir:

```
def find\_min(self):   # Gets minimum node in a subtree
    current\_node = self
    while current\_node.left\_child:
        current\_node = current\_node.left\_child
    return current\_node

def replace\_node\_in\_parent(self, new\_value=None):
    if self.parent:
        if self == self.parent.left\_child:
            self.parent.left\_child = new\_value
        else:
            self.parent.right\_child = new\_value
    if new\_value:
        new\_value.parent = self.parent

def binary\_tree\_delete(self, key):
    if key < self.key:
        self.left\_child.binary\_tree\_delete(key)
    elif key > self.key:
        self.right\_child.binary\_tree\_delete(key)
    else: # delete the key here
        if self.left\_child and self.right\_child: # if both children are present
            successor = self.right\_child.find\_min()
            self.key = successor.key
            successor.binary\_tree\_delete(successor.key)
        elif self.left\_child:   # if the node has only a \*left\* child
            self.replace\_node\_in\_parent(self.left\_child)
        elif self.right\_child:  # if the node has only a \*right\* child
            self.replace\_node\_in\_parent(self.right\_child)
        else: # this node has no children
            self.replace\_node\_in\_parent(None)

```

Dengeli ikili arama ağaçları
----------------------------

Bir ağaçtaki tüm düğümlerin sağ alt ağaçları ve sol alt ağaçları arasındaki yükseklik farkı en fazla 1 ise, o ağaç dengeli olarak tanımlanır. Ağaçların dengeli olması onların yüksekliğini azaltarak ağaç üzerinde çalışan algoritmaların performansını arttırır. Örneğin boş bir ikili arama ağacına 1, 2, 3, 4, 5, 6, 7 elemanlarını sırayla eklediğimizi düşünelim. Bu durumda elemanlar hep sağ tarafa ekleneceği için ağaç esasen bir bağlı listeye dönüşür. Halbuki, aynı elemanlar, yüksekliği 3 olan bir ağaca da yerleştirilebilirlerdi. Bu durum, dengeli ikili arama ağaçlarının icadına yol açmıştır. AVL ağacı, 2-3-4 ağacı ve kırmızı-siyah ağaçlar dengeli ağaçlara örnektir.

| * g
* t
* d
Veri yapıları |
| --- |
| Türler | Kapsayıcı **·**  Koleksiyon |
| Soyut | Liste **·**  İlişkisel dizi **·**  Çoklu harita **·**  Küme **·**  Çoklu küme **·**  Çift uçlu kuyruk **·**  Kuyruk **·**  Öncelik kuyruğu **·**  Yığın |
| Diziler | Dinamik dizi **·**  Seyrek dizi **·**  Dairesel arabellek **·**  Bit dizisi **·**  Komut çizelgesi |
| Bağlı | Bağlı liste **·**  Açılmış bağlı liste **·**  XOR bağlı liste **·**  Atlama listesi |
| Ağaçlar | B-ağaç **·**  Ağaç sıralaması (kendini dengeleyen: AA, AVL, kırmızı-siyah, şevli) **·**  Öbek (ikili, binom, Fibonacci) **·**  Önek ağacı |
| Çizgeler | Yönlendirilmiş çizge **·**  Yönlendirilmiş asiklik çizge **·**  İkili karar diyagramı **·**  Hiperçizge |
| Veri yapıları listesi |