From 2345b1cae64ae6f70cdd9a5f6828d573d47d2bc5 Mon Sep 17 00:00:00 2001
From: praxpk <23168694+praxpk@users.noreply.github.com>
Date: Tue, 13 Jan 2026 22:35:25 -0500
Subject: [PATCH 1/2] Trees-1

---
 construct_tree_pre_and_in.py | 31 +++++++++++++++++++++++++++++++
 validate_bst.py              | 25 +++++++++++++++++++++++++
 2 files changed, 56 insertions(+)
 create mode 100644 construct_tree_pre_and_in.py
 create mode 100644 validate_bst.py

diff --git a/construct_tree_pre_and_in.py b/construct_tree_pre_and_in.py
new file mode 100644
index 00000000..a6a72418
--- /dev/null
+++ b/construct_tree_pre_and_in.py
@@ -0,0 +1,31 @@
+# Definition for a binary tree node.
+from typing import List
+
+
+class TreeNode:
+    def __init__(self, x):
+        self.val = x
+        self.left = None
+        self.right = None
+
+
+class Solution:
+    def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode:
+        return self.helper(preorder, inorder)
+
+    def helper(self, preorder, inorder):
+        if len(preorder) == 0 or len(inorder) == 0:
+            return None
+
+        root = preorder[0]
+
+        inorderRootPos = inorder.index(root)
+
+        inLeft = inorder[:inorderRootPos]
+        preLeft = preorder[1 : 1 + len(inLeft)]
+        inRight = inorder[inorderRootPos + 1 :]
+        preRight = preorder[1 + len(preLeft) :]
+        t1 = TreeNode(root)
+        t1.left = self.helper(preLeft, inLeft)
+        t1.right = self.helper(preRight, inRight)
+        return t1
diff --git a/validate_bst.py b/validate_bst.py
new file mode 100644
index 00000000..39a18176
--- /dev/null
+++ b/validate_bst.py
@@ -0,0 +1,25 @@
+# Definition for a binary tree node.
+from typing import Optional
+
+
+class TreeNode:
+    def __init__(self, val=0, left=None, right=None):
+        self.val = val
+        self.left = left
+        self.right = right
+
+
+class Solution:
+    def isValidBST(self, root: Optional[TreeNode]) -> bool:
+        return self.helper(root, float("-inf"), float("inf"))
+
+    def helper(self, root, low, high):
+        if not root:
+            return True
+
+        if root.val <= low or root.val >= high:
+            return False
+
+        return self.helper(root.right, root.val, high) and self.helper(
+            root.left, low, root.val
+        )

From 7198110ff6627cd439ef60a18df9cf679ef738d5 Mon Sep 17 00:00:00 2001
From: praxpk <23168694+praxpk@users.noreply.github.com>
Date: Tue, 20 Jan 2026 23:19:35 -0500
Subject: [PATCH 2/2] Trees-1

---
 construct_tree_pre_and_in.py | 34 ++++++++++++++++++++--------------
 1 file changed, 20 insertions(+), 14 deletions(-)

diff --git a/construct_tree_pre_and_in.py b/construct_tree_pre_and_in.py
index a6a72418..6a0c946e 100644
--- a/construct_tree_pre_and_in.py
+++ b/construct_tree_pre_and_in.py
@@ -11,21 +11,27 @@ def __init__(self, x):
 
 class Solution:
     def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode:
-        return self.helper(preorder, inorder)
 
-    def helper(self, preorder, inorder):
-        if len(preorder) == 0 or len(inorder) == 0:
-            return None
+        self.preorder_index = 0
+
+        # build a hashmap to store index and value for inorder list
+        inorder_index_map = {}
+        for index, value in enumerate(inorder):
+            inorder_index_map[value] = index
 
-        root = preorder[0]
+        return self.helper(0, len(preorder) - 1, preorder, inorder_index_map)
+    
+    def helper(self, left, right, preorder, inorder_index_map):
+        if left > right:
+            return None
 
-        inorderRootPos = inorder.index(root)
+        # select the preorder_index element as the root and increment it
+        root_value = preorder[self.preorder_index]
+        root = TreeNode(root_value)
+        self.preorder_index+=1
+        
+        # build left and right subtree
+        root.left = self.helper(left, inorder_index_map[root_value] - 1, preorder, inorder_index_map)
+        root.right = self.helper(inorder_index_map[root_value] + 1, right, preorder, inorder_index_map)
 
-        inLeft = inorder[:inorderRootPos]
-        preLeft = preorder[1 : 1 + len(inLeft)]
-        inRight = inorder[inorderRootPos + 1 :]
-        preRight = preorder[1 + len(preLeft) :]
-        t1 = TreeNode(root)
-        t1.left = self.helper(preLeft, inLeft)
-        t1.right = self.helper(preRight, inRight)
-        return t1
+        return root
\ No newline at end of file