build tree from traversals new

Author: Sai-Adithya-M

data_structures/binary_tree/build_tree_from_traversal.py

@@ -1,143 +1,199 @@
-# Binary Tree Node class
+"""
+Build a binary tree from preorder + inorder or postorder + inorder traversals.
+
+This module provides two main functions:
+- build_tree_from_preorder_and_inorder()
+- build_tree_from_postorder_and_inorder()
+
+Each builds a binary tree represented by Node objects.
+
+References:
+    - https://en.wikipedia.org/wiki/Binary_tree
+    - https://en.wikipedia.org/wiki/Tree_traversal
+"""
+
+from typing import Dict, List, Optional
+
+
 class Node:
-    def __init__(self, data):
-        self.data = data
-        self.left = None
-        self.right = None
+    """
+    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.
+    """
 
-# Normal inorder traversal
-def inorder(root, out):
-    """Perform inorder traversal and append values to 'out' list."""
-    if root is None:
-        return
-    inorder(root.left, out)
-    out.append(root.data)
-    inorder(root.right, out)
+    def __init__(self, data: int) -> None:
+        self.data = data
+        self.left: Optional[Node] = None
+        self.right: Optional[Node] = None
 
 
-# === Build tree using PREORDER + INORDER ===
-def build_tree_from_pre(
-    preorder, pre_start, pre_end, inorder_seq, in_start, in_end, in_map
-):
-    """Recursive helper to build tree from preorder and inorder traversal."""
+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]
+    """
+    if root is None:
+        return []
+    return inorder_traversal(root.left) + [root.data] + inorder_traversal(root.right)
+
+
+def _build_tree_from_preorder(
+    preorder: List[int],
+    pre_start: int,
+    pre_end: int,
+    inorder_seq: 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."""
     if pre_start > pre_end or in_start > in_end:
         return None
 
-    # Root is the first element in current preorder segment
-    root_val = preorder[pre_start]
-    root = Node(root_val)
-
-    # Find the root index in inorder traversal
-    in_root_index = in_map[root_val]
-    nums_left = in_root_index - in_start
+    root_value = preorder[pre_start]
+    root = Node(root_value)
+    in_root_index = inorder_map[root_value]
+    left_subtree_size = in_root_index - in_start
 
-    # Recursively build left and right subtrees
-    root.left = build_tree_from_pre(
+    root.left = _build_tree_from_preorder(
         preorder,
         pre_start + 1,
-        pre_start + nums_left,
+        pre_start + left_subtree_size,
         inorder_seq,
         in_start,
         in_root_index - 1,
-        in_map,
+        inorder_map,
     )
-
-    root.right = build_tree_from_pre(
+    root.right = _build_tree_from_preorder(
         preorder,
-        pre_start + nums_left + 1,
+        pre_start + left_subtree_size + 1,
         pre_end,
         inorder_seq,
         in_root_index + 1,
         in_end,
-        in_map,
+        inorder_map,
     )
-
     return root
 
 
-def build_tree_pre(inorder_seq, preorder_seq):
-    """Wrapper function for building tree from preorder + inorder."""
-    in_map = {val: i for i, val in enumerate(inorder_seq)}
-    return build_tree_from_pre(
+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.
+
+    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,
-        in_map,
+        inorder_map,
     )
 
 
-# === Build tree using POSTORDER + INORDER ===
-def build_tree_from_post(
-    postorder, post_start, post_end, inorder_seq, in_start, in_end, in_map
-):
-    """Recursive helper to build tree from postorder and inorder traversal."""
+def _build_tree_from_postorder(
+    postorder: List[int],
+    post_start: int,
+    post_end: int,
+    inorder_seq: 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."""
     if post_start > post_end or in_start > in_end:
         return None
 
-    # Root is the last element in current postorder segment
-    root_val = postorder[post_end]
-    root = Node(root_val)
-
-    # Find the root index in inorder traversal
-    in_root_index = in_map[root_val]
-    nums_left = in_root_index - in_start
+    root_value = postorder[post_end]
+    root = Node(root_value)
+    in_root_index = inorder_map[root_value]
+    left_subtree_size = in_root_index - in_start
 
-    # Recursively build left and right subtrees
-    root.left = build_tree_from_post(
+    root.left = _build_tree_from_postorder(
         postorder,
         post_start,
-        post_start + nums_left - 1,
+        post_start + left_subtree_size - 1,
         inorder_seq,
         in_start,
         in_root_index - 1,
-        in_map,
+        inorder_map,
     )
-
-    root.right = build_tree_from_post(
+    root.right = _build_tree_from_postorder(
         postorder,
-        post_start + nums_left,
+        post_start + left_subtree_size,
         post_end - 1,
         inorder_seq,
         in_root_index + 1,
         in_end,
-        in_map,
+        inorder_map,
     )
-
     return root
 
 
-def build_tree_post(inorder_seq, postorder_seq):
-    """Wrapper function for building tree from postorder + inorder."""
-    in_map = {val: i for i, val in enumerate(inorder_seq)}
-    return build_tree_from_post(
+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.
+
+    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,
-        in_map,
+        inorder_map,
     )
 
 
-# === Example ===
 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]
 
-    print("=== Build BST from Preorder & Inorder ===")
-    tree_pre = build_tree_pre(inorder_seq, preorder_seq)
-    out = []
-    inorder(tree_pre, out)
-    print("Inorder:", *out)
-
-    print("=== Build BST from Postorder & Inorder ===")
-    tree_post = build_tree_post(inorder_seq, postorder_seq)
-    out = []
-    inorder(tree_post, out)
-    print("Inorder:", *out)
+    root_pre = build_tree_from_preorder_and_inorder(inorder_seq, preorder_seq)
+    print("Inorder (from Preorder+Inorder):", inorder_traversal(root_pre))
+
+    root_post = build_tree_from_postorder_and_inorder(inorder_seq, postorder_seq)
+    print("Inorder (from Postorder+Inorder):", inorder_traversal(root_post))