solved binary tree

Author: Ataba29

Easy/112.py

@@ -0,0 +1,28 @@
+# 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 hasPathSum(self, root: Optional[TreeNode], targetSum: int) -> bool:
+
+        def helper(node, curr_sum):
+            if not node:
+                return False
+
+            curr_sum += node.val
+
+            # If it's a leaf, check if the sum matches
+            if not node.left and not node.right:
+                return curr_sum == targetSum
+
+            # Otherwise, explore both sides
+            return helper(node.left, curr_sum) or helper(node.right, curr_sum)
+
+        return helper(root, 0)

Easy/222.py

@@ -0,0 +1,36 @@
+# 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 countNodes(self, root: Optional[TreeNode]) -> int:
+        if not root:
+            return 0
+        left = self.countLeft(root)
+        right = self.countRight(root)
+
+        if left == right:
+            return 2**left - 1
+        else:
+            return 1 + self.countNodes(root.left) + self.countNodes(root.right)
+
+    def countLeft(self, node):
+        h = 0
+        while node:
+            h += 1
+            node = node.left
+        return h
+
+    def countRight(self, node):
+        h = 0
+        while node:
+            h += 1
+            node = node.right
+        return h

Medium/106.py

@@ -0,0 +1,36 @@
+from collections import deque
+from typing import List, Optional
+
+
+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, inorder: List[int], postorder: List[int]) -> Optional[TreeNode]:
+        # Map each value to its index in inorder for O(1) lookups
+        mapping = {val: i for i, val in enumerate(inorder)}
+
+        postorder = deque(postorder)
+
+        def build(start, end):
+            if start > end:
+                return None
+
+            # The last element in postorder is the root
+            root_val = postorder.pop()
+            root = TreeNode(root_val)
+
+            # Find the index of the root in inorder
+            idx = mapping[root_val]
+
+            # Build right subtree first (because of postorder's order)
+            root.right = build(idx + 1, end)
+            root.left = build(start, idx - 1)
+
+            return root
+
+        return build(0, len(inorder) - 1)

Medium/114.py

@@ -0,0 +1,32 @@
+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 flatten(self, root: Optional[TreeNode]) -> None:
+        """
+        Do not return anything, modify root in-place instead.
+        """
+        curr = root
+        while curr:
+            if curr.left:
+                # Find the rightmost node in left subtree
+                rightmost = curr.left
+                while rightmost.right:
+                    rightmost = rightmost.right
+
+                # Connect right subtree to rightmost node
+                rightmost.right = curr.right
+
+                # Move left subtree to the right
+                curr.right = curr.left
+                curr.left = None
+
+            # Move to next right node
+            curr = curr.right

Medium/117.py

@@ -0,0 +1,41 @@
+# Definition for a Node.
+from collections import deque
+
+
+class Node:
+    def __init__(
+        self,
+        val: int = 0,
+        left: "Node" = None,
+        right: "Node" = None,
+        next: "Node" = None,
+    ):
+        self.val = val
+        self.left = left
+        self.right = right
+        self.next = next
+
+
+class Solution:
+    def connect(self, root: "Node") -> "Node":
+
+        q = deque()
+        q.append(root)
+
+        while q:
+            length = len(q)
+            prev = None
+            for i in range(length):
+                node = q.popleft()
+                if not node:
+                    continue
+                if node.left:
+                    q.append(node.left)
+                if node.right:
+                    q.append(node.right)
+                if prev:
+                    prev.next = node
+                prev = node
+            if prev:
+                prev.next = None
+        return root

Medium/129.py

@@ -0,0 +1,28 @@
+# 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 sumNumbers(self, root: Optional[TreeNode]) -> int:
+        summm = 0
+
+        def helper(node, summ):
+            nonlocal summm
+            if not node:
+                return
+
+            if not node.right and not node.left:
+                summm += summ * 10 + node.val
+
+            helper(node.left, summ * 10 + node.val)
+            helper(node.right, summ * 10 + node.val)
+
+        helper(root, 0)
+        return summm

Medium/173.py

@@ -0,0 +1,35 @@
+# 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 BSTIterator:
+
+    def __init__(self, root):
+        self.stack = []
+        while root:
+            self.stack.append(root)
+            root = root.left
+
+    def next(self):
+        node = self.stack.pop()
+        r = node.right
+        while r:
+            self.stack.append(r)
+            r = r.left
+        return node.val
+
+    def hasNext(self):
+        return len(self.stack) > 0
+
+
+# Your BSTIterator object will be instantiated and called as such:
+# obj = BSTIterator(root)
+# param_1 = obj.next()
+# param_2 = obj.hasNext()

Medium/236.py

@@ -0,0 +1,30 @@
+# Definition for a binary tree node.
+class TreeNode:
+    def __init__(self, x):
+        self.val = x
+        self.left = None
+        self.right = None
+
+
+class Solution:
+    def lowestCommonAncestor(
+        self, root: "TreeNode", p: "TreeNode", q: "TreeNode"
+    ) -> "TreeNode":
+        ans = None
+
+        def helper(node):
+            nonlocal ans
+            if not node:
+                return False
+            foundFirst = helper(node.left)
+            foundSecond = helper(node.right)
+
+            if (foundFirst and foundSecond) or (
+                (foundFirst or foundSecond) and (node == p or node == q)
+            ):
+                ans = node
+                return True
+            return foundFirst or foundSecond or (node == p or node == q)
+
+        helper(root)
+        return ans

README.md

@@ -17,11 +17,11 @@ This repository contains my solutions to various LeetCode problems. Each solutio
 
 ### Easy Problems
 
-- **Total Solved:** [48]
+- **Total Solved:** [50]
 
 ### Medium Problems
 
-- **Total Solved:** [122]
+- **Total Solved:** [128]
 
 ### Hard Problems