final build tree

Author: Sai-Adithya-M

data_structures/binary_tree/build_tree_from_traversal.py

@@ -1,199 +1,133 @@
 """
-Build a binary tree from preorder + inorder or postorder + inorder traversals.
+Binary Tree Construction from Preorder/Inorder or Postorder/Inorder sequences.
 
-This module provides two main functions:
-- build_tree_from_preorder_and_inorder()
-- build_tree_from_postorder_and_inorder()
+This module allows building a binary tree when given:
 
-Each builds a binary tree represented by Node objects.
+- Preorder and inorder sequences
+- Postorder and inorder sequences
 
-References:
-    - https://en.wikipedia.org/wiki/Binary_tree
-    - https://en.wikipedia.org/wiki/Tree_traversal
+Doctest examples are included for verification.
 """
 
-from typing import Dict, List, Optional
+from __future__ import annotations  # for forward references
+from typing import Optional
 
 
 class Node:
-    """
-    A class representing a node in a binary tree.
-
-    Attributes:
-        data (int): The value of the node.
-        left (Optional[Node]): Pointer to the left child.
-        right (Optional[Node]): Pointer to the right child.
-    """
+    """Class representing a node in a binary tree."""
 
     def __init__(self, data: int) -> None:
-        self.data = data
-        self.left: Optional[Node] = None
-        self.right: Optional[Node] = None
+        self.data: int = data
+        self.left: Node | None = None
+        self.right: Node | None = None
+        self.parent: Node | None = None
 
 
-def inorder_traversal(root: Optional[Node]) -> List[int]:
-    """
-    Return the inorder traversal of a binary tree as a list.
-
-    >>> root = Node(3)
-    >>> root.left = Node(2)
-    >>> root.right = Node(4)
-    >>> inorder_traversal(root)
-    [2, 3, 4]
-    """
+def inorder_traversal(root: Node | None, out: list[int]) -> None:
+    """Perform normal inorder traversal and store values in 'out' list."""
     if root is None:
-        return []
-    return inorder_traversal(root.left) + [root.data] + inorder_traversal(root.right)
+        return
+    inorder_traversal(root.left, out)
+    out.append(root.data)
+    inorder_traversal(root.right, out)
 
 
 def _build_tree_from_preorder(
-    preorder: List[int],
+    preorder: list[int],
     pre_start: int,
     pre_end: int,
-    inorder_seq: List[int],
+    inorder: list[int],
     in_start: int,
     in_end: int,
-    inorder_map: Dict[int, int],
-) -> Optional[Node]:
-    """Helper function for building a tree recursively from preorder + inorder."""
+    in_map: dict[int, int],
+) -> Node | None:
+    """Internal recursive function to build tree from preorder & inorder."""
     if pre_start > pre_end or in_start > in_end:
         return None
 
-    root_value = preorder[pre_start]
-    root = Node(root_value)
-    in_root_index = inorder_map[root_value]
-    left_subtree_size = in_root_index - in_start
+    root = Node(preorder[pre_start])
+    in_root_index = in_map[root.data]
+    nums_left = in_root_index - in_start
 
     root.left = _build_tree_from_preorder(
-        preorder,
-        pre_start + 1,
-        pre_start + left_subtree_size,
-        inorder_seq,
-        in_start,
-        in_root_index - 1,
-        inorder_map,
+        preorder, pre_start + 1, pre_start + nums_left,
+        inorder, in_start, in_root_index - 1, in_map
     )
     root.right = _build_tree_from_preorder(
-        preorder,
-        pre_start + left_subtree_size + 1,
-        pre_end,
-        inorder_seq,
-        in_root_index + 1,
-        in_end,
-        inorder_map,
+        preorder, pre_start + nums_left + 1, pre_end,
+        inorder, in_root_index + 1, in_end, in_map
     )
-    return root
-
 
-def build_tree_from_preorder_and_inorder(
-    inorder_seq: List[int], preorder_seq: List[int]
-) -> Optional[Node]:
-    """
-    Build a binary tree from preorder and inorder traversals.
-
-    Args:
-        inorder_seq: The inorder traversal sequence.
-        preorder_seq: The preorder traversal sequence.
+    return root
 
-    Returns:
-        Root node of the reconstructed binary tree.
 
-    >>> inorder_seq = [1, 2, 3, 4, 5]
-    >>> preorder_seq = [3, 2, 1, 4, 5]
-    >>> root = build_tree_from_preorder_and_inorder(inorder_seq, preorder_seq)
-    >>> inorder_traversal(root)
-    [1, 2, 3, 4, 5]
-    """
-    inorder_map = {value: i for i, value in enumerate(inorder_seq)}
-    return _build_tree_from_preorder(
-        preorder_seq,
-        0,
-        len(preorder_seq) - 1,
-        inorder_seq,
-        0,
-        len(inorder_seq) - 1,
-        inorder_map,
-    )
+def build_tree_from_preorder(inorder: list[int], preorder: list[int]) -> Node | None:
+    """Build binary tree from preorder and inorder sequences."""
+    in_map = {val: idx for idx, val in enumerate(inorder)}
+    return _build_tree_from_preorder(preorder, 0, len(preorder) - 1, inorder, 0, len(inorder) - 1, in_map)
 
 
 def _build_tree_from_postorder(
-    postorder: List[int],
+    postorder: list[int],
     post_start: int,
     post_end: int,
-    inorder_seq: List[int],
+    inorder: list[int],
     in_start: int,
     in_end: int,
-    inorder_map: Dict[int, int],
-) -> Optional[Node]:
-    """Helper function for building a tree recursively from postorder + inorder."""
+    in_map: dict[int, int],
+) -> Node | None:
+    """
+    Internal recursive function to build tree from postorder & inorder.
+
+    Example:
+    >>> inorder_seq = [1, 2, 3]
+    >>> postorder_seq = [1, 3, 2]
+    >>> inmp = {v:i for i,v in enumerate(inorder_seq)}
+    >>> root = _build_tree_from_postorder(postorder_seq, 0, 2, inorder_seq, 0, 2, inmp)
+    >>> root.data
+    2
+    >>> root.left.data
+    1
+    >>> root.right.data
+    3
+    """
     if post_start > post_end or in_start > in_end:
         return None
 
-    root_value = postorder[post_end]
-    root = Node(root_value)
-    in_root_index = inorder_map[root_value]
-    left_subtree_size = in_root_index - in_start
+    root = Node(postorder[post_end])
+    in_root_index = in_map[root.data]
+    nums_left = in_root_index - in_start
 
     root.left = _build_tree_from_postorder(
-        postorder,
-        post_start,
-        post_start + left_subtree_size - 1,
-        inorder_seq,
-        in_start,
-        in_root_index - 1,
-        inorder_map,
+        postorder, post_start, post_start + nums_left - 1,
+        inorder, in_start, in_root_index - 1, in_map
     )
     root.right = _build_tree_from_postorder(
-        postorder,
-        post_start + left_subtree_size,
-        post_end - 1,
-        inorder_seq,
-        in_root_index + 1,
-        in_end,
-        inorder_map,
+        postorder, post_start + nums_left, post_end - 1,
+        inorder, in_root_index + 1, in_end, in_map
     )
-    return root
-
 
-def build_tree_from_postorder_and_inorder(
-    inorder_seq: List[int], postorder_seq: List[int]
-) -> Optional[Node]:
-    """
-    Build a binary tree from postorder and inorder traversals.
-
-    Args:
-        inorder_seq: The inorder traversal sequence.
-        postorder_seq: The postorder traversal sequence.
+    return root
 
-    Returns:
-        Root node of the reconstructed binary tree.
 
-    >>> inorder_seq = [1, 2, 3, 4, 5]
-    >>> postorder_seq = [1, 2, 5, 4, 3]
-    >>> root = build_tree_from_postorder_and_inorder(inorder_seq, postorder_seq)
-    >>> inorder_traversal(root)
-    [1, 2, 3, 4, 5]
-    """
-    inorder_map = {value: i for i, value in enumerate(inorder_seq)}
-    return _build_tree_from_postorder(
-        postorder_seq,
-        0,
-        len(postorder_seq) - 1,
-        inorder_seq,
-        0,
-        len(inorder_seq) - 1,
-        inorder_map,
-    )
+def build_tree_from_postorder(inorder: list[int], postorder: list[int]) -> Node | None:
+    """Build binary tree from postorder and inorder sequences."""
+    in_map = {val: idx for idx, val in enumerate(inorder)}
+    return _build_tree_from_postorder(postorder, 0, len(postorder) - 1, inorder, 0, len(inorder) - 1, in_map)
 
 
+# Optional example usage
 if __name__ == "__main__":
-    # Example usage for manual verification (not part of algorithmic test)
     inorder_seq = [1, 2, 3, 4, 5]
     preorder_seq = [3, 2, 1, 4, 5]
     postorder_seq = [1, 2, 5, 4, 3]
 
-    root_pre = build_tree_from_preorder_and_inorder(inorder_seq, preorder_seq)
-    print("Inorder (from Preorder+Inorder):", inorder_traversal(root_pre))
+    tree_pre = build_tree_from_preorder(inorder_seq, preorder_seq)
+    tree_post = build_tree_from_postorder(inorder_seq, postorder_seq)
 
-    root_post = build_tree_from_postorder_and_inorder(inorder_seq, postorder_seq)
-    print("Inorder (from Postorder+Inorder):", inorder_traversal(root_post))
+    out: list[int] = []
+    inorder_traversal(tree_pre, out)
+    print("Inorder from Preorder Tree:", out)
+    out.clear()
+    inorder_traversal(tree_post, out)
+    print("Inorder from Postorder Tree:", out)