Mastering Recursion and Backtracking in Binary Trees

Day 76/100 | #100DaysOfDSA 🧩🚀 Today’s problem: Lowest Common Ancestor of a Binary Tree A fundamental tree problem that builds strong recursion intuition. Problem idea: Find the lowest node in the tree that has both given nodes as descendants. Key idea: DFS + recursion (bottom-up approach). Why? • Each subtree can independently tell if it contains p or q • Combine results while backtracking • First node where both sides return non-null → answer How it works: • If current node is null / p / q → return it • Recursively search left and right subtree • If both left & right are non-null → current node is LCA • Else return the non-null side Time Complexity: O(n) Space Complexity: O(h) (recursion stack) Big takeaway: Tree problems often rely on post-order traversal + combining child results. Understanding this pattern unlocks many binary tree problems. 🔥 Day 76 done. 🚀 #100DaysOfCode #LeetCode #DSA #Algorithms #BinaryTree #Recursion #DFS #Java #CodingJourney #ProblemSolving #InterviewPrep #TechCommunity

🚀  3-Month DSA Challenge | Week 5 Data Structures & Algorithms Practice This week, I focused on strengthening problem-solving skills using: • Sliding Window • Two Pointer Technique • Hashing ✔ Implemented optimized solutions for problems including: Longest Substring Without Repeating Characters Minimum Window Substring Container With Most Water Subarrays with K Distinct Integers 📌 Key Takeaways: Converted brute force solutions into optimized O(n) approaches Improved pattern recognition for array & string problems Strengthened Java coding and logic-building skills 📈 Consistently working towards improving problem-solving ability. #DSA #Java #ProblemSolving #SoftwareDeveloper #LeetCode #GeeksforGeeks #CodingJourney

🚀 LeetCode Challenge 27/50 💡 Approach: Classic Binary Search The problem itself demands O(log n) — no room for linear search! Binary Search is one of the most fundamental algorithms in computer science, and mastering it is non-negotiable for every developer. 🔍 Key Insight: → Maintain left and right pointers on the sorted array → Calculate mid = left + (right - left) / 2 — NOT (left+right)/2 → Why? (left+right) can cause INTEGER OVERFLOW for large values! → nums[mid] == target → found! → nums[mid] < target → search right half (left = mid+1) → nums[mid] > target → search left half (right = mid-1) 📈 Complexity: ❌ Linear Search → O(n) Time ✅ Binary Search → O(log n) Time, O(1) Space Real impact: For n=1,000,000 → Linear needs 1M comparisons, Binary Search needs just 20! That's the power of logarithms. 🔥 #LeetCode #DSA #BinarySearch #Java #ADA #PBL2 #LeetCodeChallenge #Day27of50 #CodingJourney #ComputerEngineering #AlgorithmDesign #SearchAlgorithm

Day 54 – Practice Session | Binary Trees (Part 2) | Sigma Prime – Apna College Today was dedicated to practicing advanced Binary Tree problems and improving efficiency in recursive solutions. 🔹 What I Practiced: → Implemented Diameter of a Tree ✔ Brute force approach (O(n²)) ✔ Optimized approach (O(n)) using single traversal → Solved Subtree of Another Tree ✔ Practiced tree comparison using recursion ✔ Improved understanding of identical tree logic → Worked on Top View of a Tree ✔ Used Level Order Traversal (BFS) ✔ Applied HashMap + Horizontal Distance concept #SigmaPrime #ApnaCollege #Java #DSA #BinaryTrees #ProblemSolving #Algorithms #CodingPractice #ProgrammingJourney #Consistency

Day 36 #SDE backtracking and combinatorial problems. Solved: • Combinations • Combination Sum III Key Learning: • “Combinations” helped reinforce how to generate subsets using backtracking, exploring all possible choices systematically. • “Combination Sum III” adds constraints (fixed size & target sum), making it a great example of pruning in backtracking to reduce unnecessary exploration. #LeetCode #DSA #Backtracking #Algorithms #Java #SoftwareEngineering

𝗗𝗮𝘆 𝟱𝟯 – 𝗕𝗶𝗻𝗮𝗿𝘆 𝗧𝗿𝗲𝗲𝘀 (𝗣𝗮𝗿𝘁 𝟮) | 𝗦𝗶𝗴𝗺𝗮 𝗣𝗿𝗶𝗺𝗲 – Apna College Today I moved deeper into Binary Trees, focusing on more advanced problems and optimization techniques. 🔹 𝗪𝗵𝗮𝘁 𝗜 𝗟𝗲𝗮𝗿𝗻𝗲𝗱: → 𝗗𝗶𝗮𝗺𝗲𝘁𝗲𝗿 𝗼𝗳 𝗮 𝗧𝗿𝗲𝗲 ✔ Approach 1: Using height calculation (O(n²)) ✔ Approach 2: Optimized single traversal (O(n)) → 𝗦𝘂𝗯𝘁𝗿𝗲𝗲 𝗼𝗳 𝗔𝗻𝗼𝘁𝗵𝗲𝗿 𝗧𝗿𝗲𝗲 ✔ Checking if one tree exists inside another ✔ Understanding tree comparison using recursion → 𝗧𝗼𝗽 𝗩𝗶𝗲𝘄 𝗼𝗳 𝗮 𝗧𝗿𝗲𝗲 ✔ Basic concept of horizontal distance ✔ Using Queue + HashMap for level order traversal ✔ Efficient approach to capture visible nodes #SigmaPrime #ApnaCollege #Java #DSA #BinaryTrees #DataStructures #Algorithms #ProblemSolving #Coding

🚀 Solved a neat Difference Array problem today! 💡 Problem: Given an array and a set of range queries, determine whether it’s possible to make the entire array zero using the allowed operations. 🧠 Approach: Instead of applying each query directly (which would be slow), I used: • Difference Array for efficient range updates • Prefix Sum to compute actual impact at each index ⚡ Key Idea: Each query contributes to a range. By marking where the effect starts and ends, we can efficiently calculate how many times each index can be reduced. Then, for every index: • Compare available operations with required value • If available < required → not possible 📈 Complexity: O(n + q) — efficient and scalable 🔥 Key Learning: Using a Difference Array avoids repeated work and helps optimize range-based problems significantly. #LeetCode #DSA #Java #Coding #ProblemSolving #Arrays #Algorithms

Day 2/30 — DSA Challenge 🚀 Problem: Lowest Common Ancestor of Deepest Leaves Topic: Tree + DFS Difficulty: Medium Approach: Used DFS to calculate depth of left and right subtrees At each node, compared depths: If equal → current node is LCA Else → return deeper subtree result Mistake / Challenge: Initially overcomplicated thinking about storing all deepest nodes Realized we don’t need to track nodes explicitly, depth comparison is enough Fix: Returned a Pair (node, depth) from recursion Handled everything in one DFS traversal Key Learning: Tree problems often look complex but can be simplified with recursion Focus on what needs to be returned from each call Time Taken: 60 minutes Consistency check ✅ See you on Day 3. GitHub Repo: https://lnkd.in/g87geK_g #DSA #LeetCode #Java #Trees #Recursion #LearningInPublic

Day 60/75 — Maximum Depth of Binary Tree Today’s problem was about finding the maximum depth (height) of a binary tree. Approach: • Use recursion (DFS) to explore left and right subtrees • Depth = 1 + max(leftDepth, rightDepth) • Base case: if node is null → return 0 Key logic: if (root == null) return 0; int left = maxDepth(root.left); int right = maxDepth(root.right); return 1 + Math.max(left, right); Time Complexity: O(n) Space Complexity: O(h) (recursion stack) A fundamental tree problem that builds strong understanding of recursion and DFS. 60/75 🚀 #Day60 #DSA #BinaryTree #Recursion #DFS #Java #Algorithms #LeetCode

Day 57/100 | #100DaysOfDSA ⛰️🔍 Today’s problem: Peak Index in a Mountain Array A perfect use-case of Binary Search on a pattern. Key observation: The array increases → reaches a peak → then decreases. Approach: • Use binary search on the index • Compare mid with mid + 1 • If arr[mid] > arr[mid + 1] → we are on the decreasing side → move left • Else → we are on the increasing side → move right This guarantees we always move toward the peak. Time Complexity: O(log n) Space Complexity: O(1) Big takeaway: Binary search isn’t just for sorted arrays — it works on patterns too. Recognizing these patterns is a game changer. 🔥 Day 57 done. #100DaysOfCode #LeetCode #DSA #Algorithms #BinarySearch #Arrays #Java #CodingJourney #ProblemSolving #InterviewPrep #TechCommunity