136 lines
4.4 KiB
Python
136 lines
4.4 KiB
Python
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 |