Added some basic Heap functions, created an expression calculation program, updated stack initialization

Author: pythonioncoder

Heap.py

@@ -78,18 +78,3 @@ def remove(self):
 		self._sink_down(0)
 
 		return max_value
-
-
-mh = MaxHeap()
-mh.insert(95)
-mh.insert(75)
-mh.insert(80)
-mh.insert(55)
-mh.insert(60)
-mh.insert(50)
-mh.insert(65)
-print(mh.heap)
-mh.remove()
-print(mh.heap)
-mh.remove()
-print(mh.heap)

Math.py

@@ -9,25 +9,27 @@
 
 
 def _calc(v1, v2, operator):  # Switch Statements
-	if operator == '+':
-		return v1 + v2
-	if operator == '-':
-		return v1 - v2
-	if operator == '*':
-		return v1 * v2
-	if operator == '/':
-		return v1 / v2
-	if operator == '%':
-		return v1 % v2
-	if operator == '**':
-		return v1 ** v2
-	if operator == '//':
-		return v1 // v2
-	if operator == '++':
-		return v1 + 1
-	if operator == '--':
-		return v1 + 1
-	return None
+	match operator:
+		case '+':
+			return v1 + v2
+		case '-':
+			return v1 - v2
+		case '*':
+			return v1 * v2
+		case '/':
+			return v1 / v2
+		case '%':
+			return v1 % v2
+		case '**':
+			return v1 ** v2
+		case '//':
+			return v1 // v2
+		case '++':
+			return v1 + 1
+		case '--':
+			return v1 + 1
+		case _:
+			return None
 
 
 def _calc_expression_stack(expression: Stack) -> int:

Tree.py

@@ -71,3 +71,99 @@ def contains(self, value):
 			else:
 				temp = temp.right
 		return False
+
+	def __r_contains(self, current_node, value):
+		if current_node is None:
+			return False
+		if value == current_node.value:
+			return True
+		if value < current_node.value:
+			return self.__r_contains(current_node.left, value)
+		else:
+			return self.__r_contains(current_node.right, value)
+
+	def r_contains(self, value):
+		return self.__r_contains(self.root, value)
+
+	def __r_insert(self, current_node, value):
+		if current_node is None:
+			return Node(value)
+		if value < current_node.value:
+			current_node.left = self.__r_insert(current_node.left, value)
+		elif value > current_node.value:
+			current_node.right = self.__r_insert(current_node.right, value)
+		return current_node
+
+	def r_insert(self, value):
+		if self.root is None:
+			self.root = Node(value)
+		self.__r_insert(self.root, value)
+
+	def min_value(self, current_node):
+		while current_node.left is not None:
+			current_node = current_node.left
+		return current_node.value
+
+	def __delete_node(self, current_node, value):
+		if current_node is None:
+			return None
+		if value < current_node.value:
+			current_node.left = self.__delete_node(current_node.left, value)
+		elif value > current_node.value:
+			current_node.right = self.__delete_node(current_node.right, value)
+		else:
+			if current_node.left is None and current_node.right is None:
+				return None
+			elif current_node.left is None:
+				current_node = current_node.right
+			elif current_node.right is None:
+				current_node = current_node.left
+			else:
+				sub_tree_min = self.min_value(current_node.right)
+				current_node.value = sub_tree_min
+				current_node.right = self.__delete_node(current_node.right, sub_tree_min)
+		return current_node
+
+	def delete_node(self, value):
+		self.root = self.__delete_node(self.root, value)
+
+	def bfs(self):
+		current_node = self.root
+		queue = []
+		results = []
+		queue.append(current_node)
+		while queue:
+			current_node = queue.pop(0)
+			results.append(current_node.value)
+			if current_node.left:
+				queue.append(current_node.left)
+			if current_node.right:
+				queue.append(current_node.right)
+		return results
+
+	def dfs_preorder(self):
+		results = []
+
+		def traverse(current_node):
+			results.append(current_node.value)
+			if current_node.left:
+				traverse(current_node.left)
+			if current_node.right:
+				traverse(current_node.right)
+
+		traverse(self.root)
+		return results
+
+	def dfs_postorder(self):
+		pass
+
+
+bst = BinarySearchTree()
+bst.r_insert(47)
+bst.r_insert(21)
+bst.r_insert(76)
+bst.r_insert(18)
+bst.r_insert(27)
+bst.r_insert(52)
+bst.r_insert(82)
+print(bst.dfs_preorder())