mathdatech/Python
1
0
Fork 0
mirror of https://github.com/TheAlgorithms/Python.git synced 2025-03-27 17:06:44 +00:00
Code Issues Packages Projects Releases Wiki Activity

shubhamvk03 🍉

Browse Source
This commit is contained in:
shubhamvk03 2024-09-03 20:17:22 +05:30
parent f16d38f26f
commit 8ff00a8b36
1 changed files with 58 additions and 73 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

131
data_structures/binary_tree/binary_search_tree.py
View File

@ -107,12 +107,14 @@ class Node:
""" """
>>> list(Node(0)) >>> list(Node(0))
[0] [0]
>>> list(Node(0, Node(-1), Node(1), None)) >>> list(Node(0, Node(-1), Node(1)))
[-1, 0, 1] [-1, 0, 1]
""" """
yield from self.left or [] if self.left:
yield from self.left
yield self.value yield self.value
yield from self.right or [] if self.right:
yield from self.right
def __repr__(self) -> str: def __repr__(self) -> str:
from pprint import pformat from pprint import pformat
@ -143,10 +145,10 @@ class BinarySearchTree:
return str(self.root) return str(self.root)
def __reassign_nodes(self, node: Node, new_children: Node | None) -> None: def __reassign_nodes(self, node: Node, new_children: Node | None) -> None:
if new_children is not None: # reset its kids if new_children is not None:
new_children.parent = node.parent new_children.parent = node.parent
if node.parent is not None: # reset its parent if node.parent is not None:
if node.is_right: # If it is the right child if node.is_right:
node.parent.right = new_children node.parent.right = new_children
else: else:
node.parent.left = new_children node.parent.left = new_children
@ -167,37 +169,37 @@ class BinarySearchTree:
""" """
return not self.root return not self.root
def __insert(self, value) -> None: def __insert(self, value: int) -> None:
""" """
Insert a new node in Binary Search Tree with value label Insert a new node in Binary Search Tree with value label
""" """
new_node = Node(value) # create a new Node new_node = Node(value)
if self.empty(): # if Tree is empty if self.empty():
self.root = new_node # set its root self.root = new_node
else: # Tree is not empty else:
parent_node = self.root # from root parent_node = self.root
if parent_node is None: while True:
return if value < parent_node.value:
while True: # While we don't get to a leaf
if value < parent_node.value: # We go left
if parent_node.left is None: if parent_node.left is None:
parent_node.left = new_node # We insert the new node in a leaf parent_node.left = new_node
new_node.parent = parent_node
break break
else: else:
parent_node = parent_node.left parent_node = parent_node.left
elif parent_node.right is None:
parent_node.right = new_node
break
else: else:
parent_node = parent_node.right if parent_node.right is None:
new_node.parent = parent_node parent_node.right = new_node
new_node.parent = parent_node
break
else:
parent_node = parent_node.right
def insert(self, *values) -> Self: def insert(self, *values: int) -> Self:
for value in values: for value in values:
self.__insert(value) self.__insert(value)
return self return self
def search(self, value) -> Node | None: def search(self, value: int) -> Node | None:
""" """
>>> tree = BinarySearchTree().insert(10, 20, 30, 40, 50) >>> tree = BinarySearchTree().insert(10, 20, 30, 40, 50)
>>> tree.search(10) >>> tree.search(10)
@ -221,15 +223,12 @@ class BinarySearchTree:
... ...
IndexError: Warning: Tree is empty! please use another. IndexError: Warning: Tree is empty! please use another.
""" """
if self.empty(): if self.empty():
raise IndexError("Warning: Tree is empty! please use another.") raise IndexError("Warning: Tree is empty! please use another.")
else: node = self.root
node = self.root while node is not None and node.value != value:
# use lazy evaluation here to avoid NoneType Attribute error node = node.left if value < node.value else node.right
while node is not None and node.value is not value: return node
node = node.left if value < node.value else node.right
return node
def get_max(self, node: Node | None = None) -> Node | None: def get_max(self, node: Node | None = None) -> Node | None:
""" """
@ -237,21 +236,19 @@ class BinarySearchTree:
>>> BinarySearchTree().insert(10, 20, 30, 40, 50).get_max() >>> BinarySearchTree().insert(10, 20, 30, 40, 50).get_max()
50 50
>>> BinarySearchTree().insert(-5, -1, 0.1, -0.3, -4.5).get_max() >>> BinarySearchTree().insert(-5, -1, 0, -0.3, -4.5).get_max()
{'0.1': (-0.3, None)} {'0': (-0.3, None)}
>>> BinarySearchTree().insert(1, 78.3, 30, 74.0, 1).get_max() >>> BinarySearchTree().insert(1, 78.3, 30, 74.0, 1).get_max()
{'78.3': ({'30': (1, 74.0)}, None)} {'78.3': ({'30': (1, 74.0)}, None)}
>>> BinarySearchTree().insert(1, 783, 30, 740, 1).get_max() >>> BinarySearchTree().insert(1, 783, 30, 740, 1).get_max()
{'783': ({'30': (1, 740)}, None)} {'783': ({'30': (1, 740)}, None)}
""" """
if node is None: if node is None:
if self.root is None: if self.empty():
return None return None
node = self.root node = self.root
while node.right is not None:
if not self.empty(): node = node.right
while node.right is not None:
node = node.right
return node return node
def get_min(self, node: Node | None = None) -> Node | None: def get_min(self, node: Node | None = None) -> Node | None:
@ -268,54 +265,47 @@ class BinarySearchTree:
{'1': (None, {'783': ({'30': (1, 740)}, None)})} {'1': (None, {'783': ({'30': (1, 740)}, None)})}
""" """
if node is None: if node is None:
if self.empty():
return None
node = self.root node = self.root
if self.root is None: while node.left is not None:
return None node = node.left
if not self.empty():
node = self.root
while node.left is not None:
node = node.left
return node return node
def remove(self, value: int) -> None: def remove(self, value: int) -> None:
# Look for the node with that label
node = self.search(value) node = self.search(value)
if node is None: if node is None:
msg = f"Value {value} not found" raise ValueError(f"Value {value} not found")
raise ValueError(msg)
if node.left is None and node.right is None: # If it has no children if node.left is None and node.right is None:
self.__reassign_nodes(node, None) self.__reassign_nodes(node, None)
elif node.left is None: # Has only right children elif node.left is None:
self.__reassign_nodes(node, node.right) self.__reassign_nodes(node, node.right)
elif node.right is None: # Has only left children elif node.right is None:
self.__reassign_nodes(node, node.left) self.__reassign_nodes(node, node.left)
else: else:
predecessor = self.get_max( predecessor = self.get_max(node.left)
node.left if predecessor:
) # Gets the max value of the left branch self.remove(predecessor.value)
self.remove(predecessor.value) # type: ignore[union-attr] node.value = predecessor.value
node.value = (
predecessor.value # type: ignore[union-attr]
) # Assigns the value to the node to delete and keep tree structure
def preorder_traverse(self, node: Node | None) -> Iterable: def preorder_traverse(self, node: Node | None) -> Iterable[Node]:
if node is not None: if node is not None:
yield node # Preorder Traversal yield node
yield from self.preorder_traverse(node.left) yield from self.preorder_traverse(node.left)
yield from self.preorder_traverse(node.right) yield from self.preorder_traverse(node.right)
def traversal_tree(self, traversal_function=None) -> Any: def traversal_tree(self, traversal_function=None) -> Any:
""" """
This function traversal the tree. This function traverses the tree.
You can pass a function to traversal the tree as needed by client code You can pass a function to traverse the tree as needed by client code
""" """
if traversal_function is None: if traversal_function is None:
return self.preorder_traverse(self.root) return list(self.preorder_traverse(self.root))
else: else:
return traversal_function(self.root) return traversal_function(self.root)
def inorder(self, arr: list, node: Node | None) -> None: def inorder(self, arr: list[int], node: Node | None) -> None:
"""Perform an inorder traversal and append values of the nodes to """Perform an inorder traversal and append values of the nodes to
a list named arr""" a list named arr"""
if node: if node:
@ -326,8 +316,10 @@ class BinarySearchTree:
def find_kth_smallest(self, k: int, node: Node) -> int: def find_kth_smallest(self, k: int, node: Node) -> int:
"""Return the kth smallest element in a binary search tree""" """Return the kth smallest element in a binary search tree"""
arr: list[int] = [] arr: list[int] = []
self.inorder(arr, node) # append all values to list using inorder traversal self.inorder(arr, node)
return arr[k - 1] if 0 < k <= len(arr):
return arr[k - 1]
raise IndexError("k is out of bounds")
def inorder(curr_node: Node | None) -> list[Node]: def inorder(curr_node: Node | None) -> list[Node]:
@ -346,11 +338,4 @@ def postorder(curr_node: Node | None) -> list[Node]:
""" """
node_list = [] node_list = []
if curr_node is not None: if curr_node is not None:
node_list = postorder(curr_node.left) + postorder(curr_node.right) + [curr_node] node_list = postorder(curr_node.left)
return node_list
if __name__ == "__main__":
import doctest
doctest.testmod(verbose=True)