refactor(datastructures, binary-search-tree, puzzles): remove the use of a queue in find closed value

Author: BrianLusina

datastructures/trees/binary/search_tree/__init__.py

@@ -237,33 +237,27 @@ def find_closest_value_in_bst(self, target: T) -> Optional[BinaryTreeNode]:
             return self.root
 
         # this keeps track of the minimum on both the left and the right
-        min_diff = min_diff_left = min_diff_right = float("inf")
-        closest_value = None
-        fifo_queue = FifoQueue()
-        fifo_queue.enqueue(self.root)
+        closest_node = self.root
+        min_diff = abs(target - self.root.data)
+        current = self.root
 
         # while the queue is not empty, we pop off nodes from the queue and check for their values
-        while not fifo_queue.is_empty():
-            current_node = fifo_queue.dequeue()
-
-            min_diff_left = abs(target - current_node.data)
-            min_diff_right = abs(target - current_node.data)
-
-            if min_diff_left < min_diff:
-                min_diff = min_diff_left
-                closest_value = current_node
+        while current:
+            current_diff = abs(target - self.root.data)
 
-            if min_diff_right < min_diff:
-                min_diff = min_diff_right
-                closest_value = current_node
+            if current_diff < min_diff:
+                min_diff = current_diff
+                closest_node = current
 
-            if current_node.left:
-                fifo_queue.enqueue(current_node.left)
+            if current.data == target:
+                return current
 
-            if current_node.right:
-                fifo_queue.enqueue(current_node.right)
+            if target < current.data:
+                current = current.left
+            else:
+                current = current.right
 
-        return closest_value
+        return closest_node
 
     def range_sum(self, low: int, high: int):
         """

puzzles/search/binary_search/find_closest_value/__init__.py

@@ -1,5 +1,4 @@
 from typing import Optional
-from queue import Queue
 from datastructures.trees.binary.search_tree import BinaryTreeNode
 
 
@@ -13,30 +12,24 @@ def find_closest_value_in_bst(node: BinaryTreeNode, target: int) -> Optional[int
         return node.data
 
     # this keeps track of the minimum on both the left and the right
-    min_diff = min_diff_left = min_diff_right = float("inf")
-    closest_value = None
-    fifo_queue = Queue()
-    fifo_queue.put(node)
+    closest_value = node.data
+    min_diff = abs(target - node.data)
+    current = node
 
     # while the queue is not empty, we pop off nodes from the queue and check for their values
-    while not fifo_queue.empty():
-        current_node = fifo_queue.get()
+    while current:
+        current_diff = abs(target - current.data)
 
-        min_diff_left = abs(target - current_node.data)
-        min_diff_right = abs(target - current_node.data)
+        if current_diff < min_diff:
+            min_diff = current_diff
+            closest_value = current.data
 
-        if min_diff_left < min_diff:
-            min_diff = min_diff_left
-            closest_value = current_node.data
+        if current.data == target:
+            return current.data
 
-        if min_diff_right < min_diff:
-            min_diff = min_diff_right
-            closest_value = current_node.data
-
-        if current_node.left:
-            fifo_queue.put(current_node.left)
-
-        if current_node.right:
-            fifo_queue.put(current_node.right)
+        if target < current.data:
+            current = current.left
+        else:
+            current = current.right
 
     return closest_value