Binary Tree Maximum Path Sum on LeetCode with DFS and Recursion

🚀 Day 68 of #100DaysOfCode 🔥 Solved Median of Two Sorted Arrays (LeetCode Q4) today! 💡 Problem Insight: Find the median of two sorted arrays in an efficient way without merging them. 🧠 Approach: - Use Binary Search on the smaller array - Partition both arrays such that left side has smaller elements and right side has larger ones - Ensure correct balance of elements on both sides ⚙️ Algorithm: - Apply binary search to find correct partition - Check conditions for valid split - If valid → calculate median based on total length - Else → adjust search space ⏱️ Complexity: - Time: O(log(min(n, m))) - Space: O(1) 📌 Key Learning: Brute force is not always the answer — smart partitioning can optimize everything. 💬 Think smart, not hard. #DSA #LeetCode #BinarySearch #100DaysOfCode #CodingJourney #ProblemSolving #Consistency

-- Solved LeetCode 100: Same Tree -- Today I worked on the classic binary tree problem “Same Tree”, and it turned out to be a great exercise in strengthening recursion fundamentals -- Problem Summary: -- Given two binary trees, determine whether they are identical in both structure and node values. -- Approach (Recursive DFS): At each node, I focused on 3 key checks: • If both nodes are NULL → trees match at this point • If one is NULL → structure mismatch • If values differ → not the same If all checks pass, recursively compare left and right subtrees. -- Complexity: Time: O(n) – visiting every node once Space: O(h) – recursion stack (depends on tree height) Consistency > Complexity. #LeetCode #DSA #Recursion #BinaryTree #CodingJourney #SoftwareEngineering #algorithm

Day 46 of my #50DaysOfCode challenge is done ✅ 📌 Problem Solved Geometric Sum using Recursion We were given an integer n. Task was to find the sum: 1 + 1/3 + 1/3² + ... + 1/3ⁿ Using recursion. 💻 Approach 🔹️Define a recursive function sum(n). 🔹️Base case:   ▪️If n == 0 → return 1 🔹️Recursive case:   ▪️Return sum(n-1) + 1/(3ⁿ) Each call adds one term. And moves toward smaller n. 📊 Complexity Analysis Time Complexity: O(n) Space Complexity: O(n) Due to recursion stack. 📚 What I learned today: ▫️Recursion can be used for summation of series. ▫️Each recursive call adds one term to the result. ▫️Understanding base case is important to stop recursion. ▫️Power calculations are common in series problems. Day 46 completed. Getting more comfortable with recursive formulas 🚀 #50DaysOfCode #CodingChallenge #Consistency #LearningInPublic

Day 90 of #100DaysOfCode Today I solved "Path Sum III" on LeetCode using a DFS + Recursion approach. Key Idea: We need to count all paths where the sum of node values equals the target. The path doesn’t have to start from the root — it can start from any node! Approach: • For every node, treat it as a starting point • Use DFS to explore all downward paths • Reduce the target at each step (target - node->val) • If a node matches the remaining target → count it • Repeat the process for left and right subtrees Why this works: Every node gets a chance to act as the starting point, and DFS ensures we explore all possible paths efficiently. Concepts Used: • Binary Trees • Depth First Search (DFS) • Recursion • Backtracking (implicit) Time Complexity: O(n²) in worst case Space Complexity: O(h) This problem helped me understand how to explore all possible paths in a tree, not just root-based ones — a big step forward in mastering tree problems From single path problems → to handling multiple dynamic paths… growing every day #Day90 #100DaysOfCode #LeetCode #BinaryTree #DFS #Cpp #CodingJourney

🔥 Day 171 of My LeetCode Journey Problem 112: Path Sum 💡 Problem Insight: Today’s problem was about checking whether a binary tree has a root-to-leaf path whose sum equals a target value. The key detail here is root-to-leaf — not any path. Missing that leads to wrong answers. 🧠 Concept Highlight: The solution is a clean use of DFS (recursion): Subtract the current node’s value from the target Move to left and right subtrees When you reach a leaf, check if the remaining sum is zero This ensures you explore all valid paths without unnecessary work. 💪 Key Takeaway: Tree problems often reduce to accumulating state along a path. Instead of storing paths, update the condition as you traverse. ✨ Daily Reflection: This problem reinforced how recursion naturally fits tree traversal. Once you think in terms of paths and state, the solution becomes straightforward. #Day171 #LeetCode #BinaryTree #DFS #PathSum #ProblemSolving #DSA #CodingJourney #Consistency

🚀 Day 25/60 of Daily LeetCode Challenge Today I solved Recover a Tree From Preorder Traversal — a really interesting problem combining strings + recursion + trees. 💡 My Approach: At first, the traversal string looked confusing, but I broke it down step by step. I noticed that: The number of dashes (-) represents the depth of the node The actual number after dashes is the node value So I decided to simulate the tree construction using recursion. 🔹 Step 1: Parse Depth and Value I wrote a helper to count dashes → gives me the depth Then extracted the full number (node value) from the string 🔹 Step 2: Recursive Tree Building I used recursion where I pass the expected depth If the current node’s depth doesn’t match, I return NULL Otherwise: Create the node Move index forward Recursively build left child first, then right child 🔹 Step 3: Maintain Index I kept a global/current index so I always know where I am in the string After processing a node, I update index accordingly 🧠 Key Insight: The important idea is: -> Depth (number of dashes) controls where the node should be placed in the tree Also, preorder means: -> Node → Left → Right, so I followed the same order in recursion ⏱️ Complexity: Time: O(n) (each character processed once) Space: O(h) (recursion stack) #Day25 #LeetCode #BinaryTree #Recursion #DSA #CodingJourney

Day 84/150 🚀 LeetCode 124: Binary Tree Maximum Path Sum 🧠 Problem Find the maximum path sum in a binary tree. A path can start and end at any node. 💡 Approach • Use DFS (post-order traversal) • Ignore negative paths → max(0, left/right) • Update global max using left + right + root • Return max single path for recursion ⏱ Time Complexity O(n) 📦 Space Complexity O(h) (recursion stack) ✅ Result: Accepted ⚡ Runtime: 0 ms (Beats 100%) Hard problems getting comfortable 🌳 #Day84 #LeetCode #BinaryTree #DFS #Recursion #DSA #CodingJourney #ProblemSolving

🚀 Day 23/100 — LeetCode Challenge Today's problem: Find Peak Element 🧠 Concept: Binary Search on Unsorted Data 💡 Key Idea: Even without a sorted array, binary search can be applied by analyzing the slope between elements and reducing the search space. ⚡ Time Complexity: O(log n) 📂 Solutions Repository https://lnkd.in/gkFh2mPZ A great example of how binary search is more about reducing the search space than just working on sorted arrays. #100DaysOfLeetCode #DSA #LeetCode #CodingChallenge #SoftwareEngineering

Day 37/75 – LeetCode Challenge Problem Solved: Implement Queue using Stacks (LeetCode 232) The task was to implement a queue using only stack operations. Approach: I used two stacks — one for pushing elements and another for popping/peeking. This helps maintain the FIFO order of a queue. Time Complexity: Amortized O(1) Space Complexity: O(n) Learning how different data structures can be combined to mimic each other. #LeetCode #DSA #ProblemSolving #CodingJourney #Stacks #Queue #Algorithms #CodingPractice #TechLearning