5.3: BST Dolaşma (Traversal)

💻 Python Implementasyonu

Tüm Traversal Metodları

from collections import deque

class Node:
    def __init__(self, data):
        self.data = data
        self.left = None
        self.right = None

class BST:
    def __init__(self):
        self.root = None

    def insert(self, data):
        if not self.root:
            self.root = Node(data)
            return
        c = self.root
        while True:
            if data < c.data:
                if not c.left: c.left = Node(data); return
                c = c.left
            else:
                if not c.right: c.right = Node(data); return
                c = c.right

    # ===== TRAVERSAL METODLARI =====

    def inorder(self, node=None, result=None):
        """Sol → Kök → Sağ (Sıralı çıktı)"""
        if result is None: result = []
        if node is None: node = self.root

        if node:
            self.inorder(node.left, result)   # Sol
            result.append(node.data)           # Kök
            self.inorder(node.right, result)  # Sağ
        return result

    def preorder(self, node=None, result=None):
        """Kök → Sol → Sağ"""
        if result is None: result = []
        if node is None: node = self.root

        if node:
            result.append(node.data)           # Kök
            self.preorder(node.left, result)  # Sol
            self.preorder(node.right, result) # Sağ
        return result

    def postorder(self, node=None, result=None):
        """Sol → Sağ → Kök"""
        if result is None: result = []
        if node is None: node = self.root

        if node:
            self.postorder(node.left, result)  # Sol
            self.postorder(node.right, result) # Sağ
            result.append(node.data)            # Kök
        return result

    def level_order(self):
        """BFS ile seviye seviye dolaşma"""
        if not self.root:
            return []

        result = []
        queue = deque([self.root])

        while queue:
            node = queue.popleft()  # FIFO
            result.append(node.data)

            if node.left:
                queue.append(node.left)
            if node.right:
                queue.append(node.right)

        return result

# Test
bst = BST()
for v in [50, 30, 70, 20, 40, 60, 80]:
    bst.insert(v)

print("🌳 Ağaç: 50 → (30, 70) → (20, 40, 60, 80)")
print()
print("=" * 50)
print("📋 TRAVERSAL SONUÇLARI")
print("=" * 50)
print()
print(f"📋 Inorder  (LNR): {bst.inorder()}")
print(f"   → Sıralı çıktı verir!")
print()
print(f"📦 Preorder (NLR): {bst.preorder()}")
print(f"   → Kök başta, kopyalama için")
print()
print(f"🗑️ Postorder(LRN): {bst.postorder()}")
print(f"   → Kök sonda, silme için")
print()
print(f"📊 Level Order:    {bst.level_order()}")
print(f"   → Seviye seviye, BFS")

from collections import deque

class Node:
    def __init__(self, data):
        self.data = data
        self.left = None
        self.right = None

class BST:
    def __init__(self):
        self.root = None

    def insert(self, data):
        if not self.root:
            self.root = Node(data); return
        c = self.root
        while True:
            if data < c.data:
                if not c.left: c.left = Node(data); return
                c = c.left
            else:
                if not c.right: c.right = Node(data); return
                c = c.right

    def inorder(self, node=None, res=None):
        if res is None: res = []
        if node is None: node = self.root
        if node:
            self.inorder(node.left, res)
            res.append(node.data)
            self.inorder(node.right, res)
        return res

    def preorder(self, node=None, res=None):
        if res is None: res = []
        if node is None: node = self.root
        if node:
            res.append(node.data)
            self.preorder(node.left, res)
            self.preorder(node.right, res)
        return res

bst = BST()
for v in [50, 30, 70, 20, 40, 60, 80]:
    bst.insert(v)

print(f"Inorder:  {bst.inorder()}")
print(f"Preorder: {bst.preorder()}")

Çıktı bekleniyor...

Traversal	Sıra	Özellik	Kullanım
Inorder	Sol → Kök → Sağ	BST'de sıralı çıktı	Sıralama, doğrulama
Preorder	Kök → Sol → Sağ	Kök ilk	Kopyalama, serialize
Postorder	Sol → Sağ → Kök	Kök son	Silme, ifade değerlendirme
Level Order	Seviye seviye	BFS, Queue kullanır	En kısa yol, seviye işlemleri

🚶 5.3: BST Dolaşma (Traversal)

🎯 Örnek Ağaç

Inorder (Sol-Kök-Sağ)

Preorder (Kök-Sol-Sağ)

Postorder (Sol-Sağ-Kök)

Level Order (BFS)

💻 Python Implementasyonu

📊 Özet Tablosu