Constructing Binary Tree from Inorder and Postorder Traversal - algorithm

Question

I am trying to construct a binary tree from postorder and inorder traversal. I believe the recursion part is correct however I'm not sure about the base cases. Any pointers would be appreciated.
I have tried different combination of base cases but I can't seem to get it working.
class BinaryTreeNode:
def __init__(self, data=None, left=None, right=None):
self.data = data
self.left = left
self.right = right
def binary_tree_from_postorder_inorder(postorder, inorder):
node_to_inorder_idx = {data: i for i, data in enumerate(inorder)}
def helper(
postorder_start, postorder_end, inorder_start, inorder_end
):
if postorder_end >= postorder_start or inorder_end <= inorder_start:
return None
root_inorder_idx = node_to_inorder_idx[postorder[postorder_start]]
left_subtree_size = root_inorder_idx - inorder_start
root = BinaryTreeNode(postorder[postorder_start])
root.right = helper(
postorder_start - 1,
postorder_start - 1 - left_subtree_size,
root_inorder_idx + 1,
inorder_end,
)
root.left = helper(
postorder_start - 1 - left_subtree_size,
postorder_end,
inorder_start,
root_inorder_idx,
)
return root
return helper(len(postorder) - 1, -1, 0, len(inorder))
def inorder(tree):
stack = []
results = []
while stack or tree:
if tree:
stack.append(tree)
tree = tree.left
else:
tree = stack.pop()
results.append(tree.data)
tree = tree.right
return results
inorder = ["F", "B", "A", "E", "H", "C", "D", "I", "G"]
postorder = ["F", "A", "E", "B", "I", "G", "D", "C", "H"]
root_pos_in = binary_tree_from_postorder_inorder(postorder, inorder)
print(inorder(root_pos_in))
Inputs:
inorder = ["F", "B", "A", "E", "H", "C", "D", "I", "G"]
postorder = ["F", "A", "E", "B", "I", "G", "D", "C", "H"]
Actual output using inorder traversal:
["A", "B", "E", "H", "C"]
Expected output:
["F", "B", "A", "E", "H", "C", "D", "I", "G"]

Answer 1

It's been a while since I dealt with Python, but that looks like a lot of code for what seems a simple algorithm.
Here is a an example of the application of the algorithm:
We start with
postorder | inorder
-----------|----------
|
FAEBIGDCH | FBAEHCDIG
^ |
| |
`-+-------------- last value of postorder: 'H': this is the root value
|
FAEBIGDCH | FBAEHCDIG
| ^
| |
| `------- index of 'H' in inorder: 4
|
FAEB_.... | FBAE_....
^ | ^
| | |
| | `--------- everything before index 4
| |
`-------+-------------- everything before index 4
|
....IGDC_ | ...._CDIG
^ | ^
| | |
| | `---- everything beginning with index 5 (4 + 1)
| |
`---+-------------- everything between index 4 and the 'H' at the end
|
FAEB | FBAE
^ | ^
| | |
`-------+---+---------- recur on these if not empty: this is the left child
|
IGDC | CDIG
^ | ^
| | |
`--+--------+----- recur on these if not empty: this is the right child
This will quickly lead us to a tree like
H
|
+--------+--------+
| |
B C
| |
+-----+-----+ +-----+
| | |
F E D
| |
+---+ +---+
| |
A G
+-+
|
I
So while I can't really critique your Python, I can offer a pretty simple JS version:
const makeTree = (
postord, inord,
len = postord.length, val = postord[len - 1], idx = inord.indexOf(val)
) =>
len == 1
? {val}
: {
val,
...(idx > 0 ? {left: makeTree(postord.slice(0, idx), inord.slice(0, idx))} : {}),
...(idx < len - 1 ? {right: makeTree(postord.slice(idx, len - 1), inord.slice(idx + 1, len))} : {})
}
const postOrder = ["F", "A", "E", "B", "I", "G", "D", "C", "H"]
const inOrder = ["F", "B", "A", "E", "H", "C", "D", "I", "G"]
console .log (
makeTree (postOrder, inOrder)
)

Answer 2

After fiddling for a little longer, I was able to fix the problem. See my updated function below:
def binary_tree_from_postorder_inorder(postorder, inorder):
if not inorder or not postorder or len(postorder) != len(inorder):
return None
node_to_inorder_idx = {data: i for i, data in enumerate(inorder)}
def helper(postorder_start, postorder_end, inorder_start, inorder_end):
if postorder_start > postorder_end or inorder_start > inorder_end:
return None
root_index = node_to_inorder_idx[postorder[postorder_end]]
left_subtree_size = root_index - inorder_start
return BinaryTreeNode(
postorder[postorder_end],
helper(
postorder_start,
postorder_start + left_subtree_size - 1,
inorder_start,
root_index - 1,
),
helper(
postorder_start + left_subtree_size,
postorder_end - 1,
root_index + 1,
inorder_end,
),
)
return helper(0, len(postorder) - 1, 0, len(inorder) - 1)