Merge branch 'binary_tree' into lab_1

skorohodovsa/.gitignore

@@ -1,2 +1,6 @@
-/.ruff_check
-/.vscode
+.ruff_cache/
+.vscode/*
+.idea/
+/.vscode
+
+task_1/work.py

skorohodovsa/task_1/binary_tree.py

@@ -0,0 +1,136 @@
+class BSTNode:
+    def __init__(self, name: str, phone: str):
+        self.name = name
+        self.phone = phone
+        self.left = None
+        self.right = None
+
+
+class BinarySearchTree:
+    def __init__(self):
+        self.root = None
+    
+    def insert(self, name: str, phone: str) -> None:
+        if self.root is None:
+            self.root = BSTNode(name, phone)
+        else:
+            self._insert_recursive(self.root, name, phone)
+    
+    def _insert_recursive(self, node: BSTNode, name: str, phone: str) -> BSTNode:
+        if node is None:
+            return BSTNode(name, phone)
+        
+        if name < node.name:
+            node.left = self._insert_recursive(node.left, name, phone)
+        elif name > node.name:
+            node.right = self._insert_recursive(node.right, name, phone)
+        else:
+            node.phone = phone
+        
+        return node
+    
+    def search(self, name: str):
+        return self._search_recursive(self.root, name)
+    
+    def _search_recursive(self, node: BSTNode, name: str):
+        if node is None:
+            return None
+        
+        if name == node.name:
+            return node.phone
+        elif name < node.name:
+            return self._search_recursive(node.left, name)
+        else:
+            return self._search_recursive(node.right, name)
+    
+    def delete(self, name: str) -> bool:
+        self.root, deleted = self._delete_recursive(self.root, name)
+        return deleted
+    
+    def _delete_recursive(self, node: BSTNode, name: str):
+        if node is None:
+            return None, False
+        
+        deleted = False
+        if name < node.name:
+            node.left, deleted = self._delete_recursive(node.left, name)
+        elif name > node.name:
+            node.right, deleted = self._delete_recursive(node.right, name)
+        else:
+            deleted = True
+            
+            if node.left is None and node.right is None:
+                return None, True
+            
+            if node.left is None:
+                return node.right, True
+            if node.right is None:
+                return node.left, True
+            
+            min_node = self._find_min(node.right)
+            node.name = min_node.name
+            node.phone = min_node.phone
+            node.right, _ = self._delete_recursive(node.right, min_node.name)
+        
+        return node, deleted
+    
+    def _find_min(self, node: BSTNode) -> BSTNode:
+        current = node
+        while current.left:
+            current = current.left
+        return current
+    
+    def inorder(self) -> list:
+        result = []
+        self._inorder_recursive(self.root, result)
+        return result
+    
+    def _inorder_recursive(self, node: BSTNode, result: list) -> None:
+        if node:
+            self._inorder_recursive(node.left, result)
+            result.append({'name': node.name, 'phone': node.phone})
+            self._inorder_recursive(node.right, result)
+    
+    def preorder(self) -> list:
+        result = []
+        self._preorder_recursive(self.root, result)
+        return result
+    
+    def _preorder_recursive(self, node: BSTNode, result: list) -> None:
+        if node:
+            result.append({'name': node.name, 'phone': node.phone})
+            self._preorder_recursive(node.left, result)
+            self._preorder_recursive(node.right, result)
+    
+    def postorder(self) -> list:
+        result = []
+        self._postorder_recursive(self.root, result)
+        return result
+    
+    def _postorder_recursive(self, node: BSTNode, result: list) -> None:
+        if node:
+            self._postorder_recursive(node.left, result)
+            self._postorder_recursive(node.right, result)
+            result.append({'name': node.name, 'phone': node.phone})
+    
+    def get_height(self) -> int:
+        return self._height_recursive(self.root)
+    
+    def _height_recursive(self, node: BSTNode) -> int:
+        if node is None:
+            return 0
+        return 1 + max(self._height_recursive(node.left), self._height_recursive(node.right))
+    
+    def get_size(self) -> int:
+        return self._size_recursive(self.root)
+    
+    def _size_recursive(self, node: BSTNode) -> int:
+        if node is None:
+            return 0
+        return 1 + self._size_recursive(node.left) + self._size_recursive(node.right)
+    
+    def clear(self) -> None:
+        self.root = None
+    
+    def is_empty(self) -> bool:
+        return self.root is None