From 9eb81f4bfbecb98f13902225493f3bd8bf029cea Mon Sep 17 00:00:00 2001
From: sreevardhan1099 <sreevardhan1099@gmail.com>
Date: Mon, 26 Jan 2026 00:34:52 -0500
Subject: [PATCH] Complete Trees-1

---
 Problem-1.py | 41 +++++++++++++++++++++++++++++++++++++++++
 Problem-2.py | 38 ++++++++++++++++++++++++++++++++++++++
 2 files changed, 79 insertions(+)
 create mode 100644 Problem-1.py
 create mode 100644 Problem-2.py

diff --git a/Problem-1.py b/Problem-1.py
new file mode 100644
index 00000000..f6f6b856
--- /dev/null
+++ b/Problem-1.py
@@ -0,0 +1,41 @@
+#98. Validate Binary Search Tree
+# Time Complexity :O(n)
+# Space Complexity :O(h)
+# Did this code successfully run on Leetcode :yes
+# Any problem you faced while coding this :no
+
+
+# Your code here along with comments explaining your approach
+#set a prev value to None, prev should track the prev node of each node check if prev is not None and prev is less than current root value, else flag is set to false (conditional recursion)
+# time - O(n)
+#space - O(h)
+#
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+
+class Solution:
+    #global vaariables
+    def __init__(self):
+        self.flag = True
+        self.prev = None
+
+    def isValidBST(self, root: Optional[TreeNode]) -> bool:
+        self.helper(root)
+        return self.flag
+    #inorder
+    def helper(self, root):
+        if root is None:
+            return
+        #conditional recursion
+        if not self.flag:
+            return
+        self.helper(root.left)
+        #check prev is less than current value
+        if self.prev is not None and self.prev.val >= root.val:
+            self.flag = False
+        self.prev=root
+        self.helper(root.right)
diff --git a/Problem-2.py b/Problem-2.py
new file mode 100644
index 00000000..da0e8473
--- /dev/null
+++ b/Problem-2.py
@@ -0,0 +1,38 @@
+#105. Construct Binary Tree from Preorder and Inorder Traversal
+# Time Complexity :O(n)
+# Space Complexity :O(h)
+# Did this code successfully run on Leetcode :yes
+# Any problem you faced while coding this :no
+
+# Your code here along with comments explaining your approach
+#from preorder identify the root element
+# fint the root element index in the inorder array
+# Inorder array, everything on left of root is left subtree of root and everything on right is right subtree of root
+#make recusive calls to implement the above logic
+#time - O(n)
+#space - O(h)
+
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def buildTree(self, preorder: List[int], inorder: List[int]) -> Optional[TreeNode]:
+        self.idx=0#index of preorder list
+        d=dict()#map for maintaining index of values in inorder
+        for i in range(0,len(inorder)):
+            d[inorder[i]] = i
+        return self.helper(preorder, d, 0, len(inorder)-1)
+    def helper(self, preorder, d, start, end):
+        if(start>end):
+            return None
+
+        curr=preorder[self.idx]
+        root = TreeNode(curr)
+        self.idx+=1
+        root.left = self.helper(preorder, d, start, d[curr]-1)#leftsubtree of current node
+        root.right = self.helper(preorder, d, d[curr]+1, end)#right subtree of current node
+        return root
+        
\ No newline at end of file