binary_search_traversals.py made memory-friendly using generators. Fixes #8725 completely.

data_structures/binary_tree/binary_tree_traversals.py

@@ -1,9 +1,8 @@
 from __future__ import annotations
 
 from collections import deque
-from collections.abc import Generator, Sequence
+from collections.abc import Generator
 from dataclasses import dataclass
-from typing import Any
 
 
 # https://en.wikipedia.org/wiki/Tree_traversal
@@ -94,96 +93,86 @@ def height(root: Node | None) -> int:
  return (max(height(root.left), height(root.right)) + 1) if root else 0
 
 
-def level_order(root: Node | None) -> Sequence[Node | None]:
+def level_order(root: Node | None) -> Generator[int, None, None]:
  """
  Returns a list of nodes value from a whole binary tree in Level Order Traverse.
  Level Order traverse: Visit nodes of the tree level-by-level.
  """
- output: list[Any] = []
 
  if root is None:
- return output
+ return
 
  process_queue = deque([root])
 
  while process_queue:
  node = process_queue.popleft()
-output.append(node.data)
+yield node.data
 
  if node.left:
  process_queue.append(node.left)
  if node.right:
  process_queue.append(node.right)
- return output
 
 
 def get_nodes_from_left_to_right(
  root: Node | None, level: int
-) -> Sequence[Node | None]:
+) -> Generator[int, None, None]:
  """
  Returns a list of nodes value from a particular level:
  Left to right direction of the binary tree.
  """
- output: list[Any] = []
 
- def populate_output(root: Node | None, level: int) -> None:
+ def populate_output(root: Node | None, level: int) -> Generator[int, None, None]:
  if not root:
  return
  if level == 1:
-output.append(root.data)
+yield root.data
  elif level > 1:
- populate_output(root.left, level - 1)
- populate_output(root.right, level - 1)
+yield from populate_output(root.left, level - 1)
+yield from populate_output(root.right, level - 1)
 
- populate_output(root, level)
- return output
+ yield from populate_output(root, level)
 
 
 def get_nodes_from_right_to_left(
  root: Node | None, level: int
-) -> Sequence[Node | None]:
+) -> Generator[int, None, None]:
  """
  Returns a list of nodes value from a particular level:
  Right to left direction of the binary tree.
  """
- output: list[Any] = []
 
- def populate_output(root: Node | None, level: int) -> None:
+ def populate_output(root: Node | None, level: int) -> Generator[int, None, None]:
  if root is None:
  return
  if level == 1:
-output.append(root.data)
+yield root.data
  elif level > 1:
- populate_output(root.right, level - 1)
- populate_output(root.left, level - 1)
+yield from populate_output(root.right, level - 1)
+yield from populate_output(root.left, level - 1)
 
- populate_output(root, level)
- return output
+ yield from populate_output(root, level)
 
 
-def zigzag(root: Node | None) -> Sequence[Node | None] | list[Any]:
+def zigzag(root: Node | None) -> Generator[int, None, None]:
  """
  ZigZag traverse:
  Returns a list of nodes value from left to right and right to left, alternatively.
  """
  if root is None:
- return []
-
- output: list[Sequence[Node | None]] = []
+ return
 
  flag = 0
  height_tree = height(root)
 
  for h in range(1, height_tree + 1):
  if not flag:
-output.append(get_nodes_from_left_to_right(root, h))
+yield from get_nodes_from_left_to_right(root, h)
  flag = 1
  else:
-output.append(get_nodes_from_right_to_left(root, h))
+yield from get_nodes_from_right_to_left(root, h)
  flag = 0
 
- return output
-
 
 def main() -> None: # Main function for testing.
  # Create binary tree.
@@ -198,15 +187,15 @@ def main() -> None: # Main function for testing.
  print(f"Height of Tree: {height(root)}", "\n")
 
  print("Complete Level Order Traversal: ")
- print(level_order(root), "\n")
+ print(f"{list(level_order(root))} \n")
 
  print("Level-wise order Traversal: ")
 
  for level in range(1, height(root) + 1):
- print(f"Level {level}:", get_nodes_from_left_to_right(root, level=level))
+ print(f"Level {level}:", list(get_nodes_from_left_to_right(root, level=level)))
 
  print("\nZigZag order Traversal: ")
- print(zigzag(root))
+ print(f"{list(zigzag(root))}")
 
 
 if __name__ == "__main__":