From 1ec0ff0f26ee5cfc89c03617ec4b684638182b7e Mon Sep 17 00:00:00 2001 From: night007-hub Date: Sun, 26 Oct 2025 16:58:13 +0530 Subject: [PATCH 1/6] build tree using traversals --- .../binary_tree/build_tree_from_traversal.py | 105 ++++++++++++++++++ 1 file changed, 105 insertions(+) create mode 100644 data_structures/binary_tree/build_tree_from_traversal.py diff --git a/data_structures/binary_tree/build_tree_from_traversal.py b/data_structures/binary_tree/build_tree_from_traversal.py new file mode 100644 index 000000000000..b1e47a362967 --- /dev/null +++ b/data_structures/binary_tree/build_tree_from_traversal.py @@ -0,0 +1,105 @@ +# Binary Tree Node class +class Node: + def __init__(self, data): + self.data = data + self.left = None + self.right = None + + +# 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) + + +# === 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.""" + 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 + + # Recursively build left and right subtrees + root.left = build_tree_from_pre( + preorder, pre_start + 1, pre_start + nums_left, + inorder_seq, in_start, in_root_index - 1, in_map) + + root.right = build_tree_from_pre( + preorder, pre_start + nums_left + 1, pre_end, + inorder_seq, in_root_index + 1, in_end, in_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( + preorder_seq, 0, len(preorder_seq) - 1, + inorder_seq, 0, len(inorder_seq) - 1, in_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.""" + 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 + + # Recursively build left and right subtrees + root.left = build_tree_from_post( + postorder, post_start, post_start + nums_left - 1, + inorder_seq, in_start, in_root_index - 1, in_map) + + root.right = build_tree_from_post( + postorder, post_start + nums_left, post_end - 1, + inorder_seq, in_root_index + 1, in_end, in_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( + postorder_seq, 0, len(postorder_seq) - 1, + inorder_seq, 0, len(inorder_seq) - 1, in_map) + + +# === Example === +if __name__ == "__main__": + 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) From a7bb97cb0b14829e7de7c99ace7ec939ed1f6316 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Sun, 26 Oct 2025 11:51:34 +0000 Subject: [PATCH 2/6] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- .../binary_tree/build_tree_from_traversal.py | 70 ++++++++++++++----- 1 file changed, 54 insertions(+), 16 deletions(-) diff --git a/data_structures/binary_tree/build_tree_from_traversal.py b/data_structures/binary_tree/build_tree_from_traversal.py index b1e47a362967..dc46896f66b1 100644 --- a/data_structures/binary_tree/build_tree_from_traversal.py +++ b/data_structures/binary_tree/build_tree_from_traversal.py @@ -17,8 +17,9 @@ def inorder(root, out): # === Build tree using PREORDER + INORDER === -def build_tree_from_pre(preorder, pre_start, pre_end, - inorder_seq, in_start, in_end, in_map): +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.""" if pre_start > pre_end or in_start > in_end: return None @@ -33,12 +34,24 @@ def build_tree_from_pre(preorder, pre_start, pre_end, # Recursively build left and right subtrees root.left = build_tree_from_pre( - preorder, pre_start + 1, pre_start + nums_left, - inorder_seq, in_start, in_root_index - 1, in_map) + preorder, + pre_start + 1, + pre_start + nums_left, + inorder_seq, + in_start, + in_root_index - 1, + in_map, + ) root.right = build_tree_from_pre( - preorder, pre_start + nums_left + 1, pre_end, - inorder_seq, in_root_index + 1, in_end, in_map) + preorder, + pre_start + nums_left + 1, + pre_end, + inorder_seq, + in_root_index + 1, + in_end, + in_map, + ) return root @@ -47,13 +60,20 @@ 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( - preorder_seq, 0, len(preorder_seq) - 1, - inorder_seq, 0, len(inorder_seq) - 1, in_map) + preorder_seq, + 0, + len(preorder_seq) - 1, + inorder_seq, + 0, + len(inorder_seq) - 1, + in_map, + ) # === Build tree using POSTORDER + INORDER === -def build_tree_from_post(postorder, post_start, post_end, - inorder_seq, in_start, in_end, in_map): +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.""" if post_start > post_end or in_start > in_end: return None @@ -68,12 +88,24 @@ def build_tree_from_post(postorder, post_start, post_end, # Recursively build left and right subtrees root.left = build_tree_from_post( - postorder, post_start, post_start + nums_left - 1, - inorder_seq, in_start, in_root_index - 1, in_map) + postorder, + post_start, + post_start + nums_left - 1, + inorder_seq, + in_start, + in_root_index - 1, + in_map, + ) root.right = build_tree_from_post( - postorder, post_start + nums_left, post_end - 1, - inorder_seq, in_root_index + 1, in_end, in_map) + postorder, + post_start + nums_left, + post_end - 1, + inorder_seq, + in_root_index + 1, + in_end, + in_map, + ) return root @@ -82,8 +114,14 @@ 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( - postorder_seq, 0, len(postorder_seq) - 1, - inorder_seq, 0, len(inorder_seq) - 1, in_map) + postorder_seq, + 0, + len(postorder_seq) - 1, + inorder_seq, + 0, + len(inorder_seq) - 1, + in_map, + ) # === Example === From 570262758ebec14f393a27769d2124b680e99f17 Mon Sep 17 00:00:00 2001 From: night007-hub Date: Sun, 26 Oct 2025 17:43:20 +0530 Subject: [PATCH 3/6] build tree from traversals new --- .../binary_tree/build_tree_from_traversal.py | 210 +++++++++++------- 1 file changed, 133 insertions(+), 77 deletions(-) diff --git a/data_structures/binary_tree/build_tree_from_traversal.py b/data_structures/binary_tree/build_tree_from_traversal.py index dc46896f66b1..f09546c9c070 100644 --- a/data_structures/binary_tree/build_tree_from_traversal.py +++ b/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)) From dff30d053e8b8fd99e49c3514211e67e7b0751ef Mon Sep 17 00:00:00 2001 From: night007-hub Date: Sun, 26 Oct 2025 17:59:55 +0530 Subject: [PATCH 4/6] final build tree --- .../binary_tree/build_tree_from_traversal.py | 216 ++++++------------ 1 file changed, 75 insertions(+), 141 deletions(-) diff --git a/data_structures/binary_tree/build_tree_from_traversal.py b/data_structures/binary_tree/build_tree_from_traversal.py index f09546c9c070..b55d22554a89 100644 --- a/data_structures/binary_tree/build_tree_from_traversal.py +++ b/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) From ee149d6d6695c32aecb4168d1edc6fcc1d09f34f Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Sun, 26 Oct 2025 12:30:42 +0000 Subject: [PATCH 5/6] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- .../binary_tree/build_tree_from_traversal.py | 44 ++++++++++++++----- 1 file changed, 34 insertions(+), 10 deletions(-) diff --git a/data_structures/binary_tree/build_tree_from_traversal.py b/data_structures/binary_tree/build_tree_from_traversal.py index b55d22554a89..3c3e849f4704 100644 --- a/data_structures/binary_tree/build_tree_from_traversal.py +++ b/data_structures/binary_tree/build_tree_from_traversal.py @@ -50,12 +50,22 @@ def _build_tree_from_preorder( nums_left = in_root_index - in_start root.left = _build_tree_from_preorder( - preorder, pre_start + 1, pre_start + nums_left, - inorder, in_start, in_root_index - 1, in_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 + nums_left + 1, pre_end, - inorder, in_root_index + 1, in_end, in_map + preorder, + pre_start + nums_left + 1, + pre_end, + inorder, + in_root_index + 1, + in_end, + in_map, ) return root @@ -64,7 +74,9 @@ def _build_tree_from_preorder( 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) + return _build_tree_from_preorder( + preorder, 0, len(preorder) - 1, inorder, 0, len(inorder) - 1, in_map + ) def _build_tree_from_postorder( @@ -99,12 +111,22 @@ def _build_tree_from_postorder( nums_left = in_root_index - in_start root.left = _build_tree_from_postorder( - postorder, post_start, post_start + nums_left - 1, - inorder, in_start, in_root_index - 1, in_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 + nums_left, post_end - 1, - inorder, in_root_index + 1, in_end, in_map + postorder, + post_start + nums_left, + post_end - 1, + inorder, + in_root_index + 1, + in_end, + in_map, ) return root @@ -113,7 +135,9 @@ def _build_tree_from_postorder( 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) + return _build_tree_from_postorder( + postorder, 0, len(postorder) - 1, inorder, 0, len(inorder) - 1, in_map + ) # Optional example usage From 2ffa548c572f12bb0aa99f83564b987b1a6a32be Mon Sep 17 00:00:00 2001 From: night007-hub Date: Sun, 26 Oct 2025 18:03:04 +0530 Subject: [PATCH 6/6] final2 changes --- data_structures/binary_tree/build_tree_from_traversal.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/data_structures/binary_tree/build_tree_from_traversal.py b/data_structures/binary_tree/build_tree_from_traversal.py index 3c3e849f4704..5c7a5d674fea 100644 --- a/data_structures/binary_tree/build_tree_from_traversal.py +++ b/data_structures/binary_tree/build_tree_from_traversal.py @@ -10,7 +10,6 @@ """ from __future__ import annotations # for forward references -from typing import Optional class Node: @@ -95,7 +94,9 @@ def _build_tree_from_postorder( >>> 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 = _build_tree_from_postorder( + ... postorder_seq, 0, 2, inorder_seq, 0, 2, inmp + ... ) >>> root.data 2 >>> root.left.data @@ -140,7 +141,6 @@ def build_tree_from_postorder(inorder: list[int], postorder: list[int]) -> Node ) -# Optional example usage if __name__ == "__main__": inorder_seq = [1, 2, 3, 4, 5] preorder_seq = [3, 2, 1, 4, 5]