Solved LeetCode #110: Balanced Binary Tree with Java

✨ LeetCode 104 – Maximum Depth of Binary Tree Today I solved another interesting Binary Tree problem 🌳 🧩 Problem Summary: Given the root of a binary tree, we need to find its maximum depth — the number of nodes along the longest path from the root down to the farthest leaf. 💡 Intuition: We can use recursion — At each node, the maximum depth is 1 + max(depth of left subtree, depth of right subtree). If the node is null, the depth is 0. 🧠 Approach: ✔️ Use a simple DFS traversal ✔️ Recursively calculate left and right subtree depths ✔️ Add 1 for the current node 🕒 Complexity: Time: O(N) — visit each node once Space: O(H) — recursion stack (H = height of the tree) #LeetCode #Java #DSA #BinaryTree #Recursion #CodingJourney #100DaysOfCode

🌳 Day 60 of #100DaysOfCode 🌳 🔹 Problem: Balanced Binary Tree – LeetCode ✨ Approach: Used a post-order DFS traversal to calculate subtree heights while checking balance at every node. If the height difference of any subtree exceeds 1, return -1 immediately for an early exit — efficient and elegant! ⚡ 📊 Complexity Analysis: Time: O(n) — each node visited once Space: O(h) — recursion stack space, where h is the tree height ✅ Runtime: 0 ms (Beats 100%) ✅ Memory: 44.29 MB 🔑 Key Insight: A balanced tree isn’t just about equal heights — it’s about smart recursion that detects imbalance early, saving both time and memory. 🌿 #LeetCode #100DaysOfCode #Java #DSA #BinaryTree #Recursion #ProblemSolving #AlgorithmDesign #CodeJourney #ProgrammingChallenge

🚀 Just Solved LeetCode #1367 — Linked List in Binary Tree 📘 Problem: Given the head of a linked list and the root of a binary tree, determine whether all the elements of the linked list appear as a downward path in the binary tree. Downward means starting from any node and moving only to child nodes. Example: Input → head = [4,2,8], root = [1,4,4,null,2,2,null,1,null,6,8,null,null,null,null,1,3] Output → true Explanation → Nodes in blue form a subpath in the binary tree. 🧠 My Approach: I used recursion to check whether the linked list sequence can be found starting from any node in the binary tree. 1️⃣ For each node in the tree, check if the list starting from `head` matches the downward path from that node. 2️⃣ If not, recursively check the left and right subtrees. 3️⃣ Used a helper function `checkPath()` to verify if a valid path continues as the recursion goes deeper. 💡 What I Learned: ✅ How to combine linked list and binary tree traversal logic ✅ How recursion can efficiently check multiple starting points ✅ Improved my understanding of tree path traversal and backtracking logic #LeetCode #Java #DSA #BinaryTree #LinkedList #CodingUpdate #LearningByDoing

📌 Day 38/100 – Make array elements equal to zero (LeetCode 3354) 🔹 Problem: Given an integer array nums, each element can be a number or zero. You need to find how many zeros in the array can be replaced by either +1 or -1 such that the total sum on both sides of that zero (left and right) remains balanced or differs by 1. 🔹 Approach: First, calculate the total sum s of all elements. Maintain a prefix sum l as you iterate. For each zero: If l * 2 == s, both +1 and -1 replacements are valid → add 2 to ans. If |l * 2 - s| == 1, only one replacement is valid → add 1 to ans. Return the total count ans. 🔹 Key Learning: Prefix sums simplify balance-based problems. Comparing 2 * prefixSum with total sum helps quickly check left-right equilibrium. 🔹 Complexity: Time: O(n) — single pass through array Space: O(1) — no extra storage used 🔹 Hashtags: #Day38Of100 #LeetCode3354 #100DaysOfCode #Java #DSA #ProblemSolving #PrefixSum #CodingChallenge

#Day-70) LeetCode #3234 – Count Substrings With Dominant Ones Just solved an interesting binary string problem where a substring is considered dominant if the number of 1s is greater than or equal to the square of the number of 0s. 🔍 Challenge: Efficiently count all such substrings in a given binary string. 🧠 My Approach (Java): Used a prefix sum array to track the balance between 1s and 0s Explored substring ranges with a smart condition check Focused on clean logic and edge case handling 📈 Why it matters: This problem blends math with string manipulation and highlights how preprocessing (like prefix sums) can drastically reduce brute-force overhead. 📎 Code snippet attached — open to feedback or alternate strategies! #LeetCode #Java #DSA #BinaryStrings #ProblemSolving #CodingInPublic #TechJourney

✅Day 41 : Leetcode 153 - Find Minimum in Rotated Sorted Array #60DayOfLeetcodeChallenge 🧩 Problem Statement Given a sorted array that has been rotated at an unknown pivot, find the minimum element in the array. The array contains unique elements, and the solution must run in O(log n) time. 💡 My Approach I used a binary search technique to efficiently find the minimum element. I maintained two pointers, low and high. At each step, I calculated the mid-point. If the left part (nums[low] to nums[mid]) was sorted, I updated my answer with the smaller of nums[low] and current ans, and moved low to mid + 1. Otherwise, I updated my answer with nums[mid] and moved high to mid - 1. This approach ensures we keep narrowing the search space toward the minimum element. ⏱️ Time Complexity O(log n) — Because the search space is halved in each iteration. #BinarySearch #LeetCode #RotatedSortedArray #DSA #CodingPractice #Java #ProblemSolving

🔢 Day 47 of #LeetCode100DaysChallenge Solved LeetCode 79: Word Search — a classic backtracking problem that beautifully blends recursion and grid traversal. 🧩 Problem: Given a 2D grid of characters and a word, determine if the word can be formed using sequentially adjacent cells (up, down, left, right), where each cell can be used only once. 💡 Approach Used — Backtracking (DFS): 1️⃣ Start from each cell that matches the first character. 2️⃣ Explore in all four directions recursively. 3️⃣ Temporarily mark visited cells to avoid reuse. 4️⃣ If the entire word is matched, return true; otherwise, backtrack. ⚙️ Complexity: Time: O(N × 4ᴸ) — where N is the total number of cells, and L is the word length. Space: O(L) — recursion depth. ✨ Key Takeaways: ✅ Strengthened understanding of recursion and backtracking. ✅ Learned to manage visited states effectively in grid problems. ✅ Great exercise in applying DFS to real-world matrix traversal cases. #LeetCode #100DaysOfCode #Java #Backtracking #Recursion #ProblemSolving #DSA #WomenInTech #CodingJourney

✅Day 43 : Leetcode 540 - Single Element in a Sorted Array #60DayOfLeetcodeChallenge 🧩 Problem Statement You are given a sorted array consisting of integers where every element appears exactly twice, except for one element which appears only once. Your task is to find the single element that appears only once. You must write an algorithm that runs in O(log n) time and uses O(1) space. 💡 My Approach (Using Binary Search) In my approach, I used binary search to efficiently find the single element. I handled edge cases first — when the unique element is at the start or end of the array. Then I applied binary search between low = 1 and high = n - 2. For each mid index, I checked if nums[mid] is different from both its neighbors (nums[mid-1] and nums[mid+1]). If true, that’s the unique element. Otherwise, I used the property of pairs to decide which side to continue searching: If the left half (up to mid) has an even number of elements, the single element is on the right side. Otherwise, it’s on the left side. This method ensures logarithmic time by reducing the search range by half at each step. ⏱️ Time Complexity O(log n) — Binary search divides the array in half each iteration. 💾 Space Complexity O(1) — Constant extra space used. #BinarySearch #LeetCode #DSA #Java #LeetcodeMedium #ArrayProblem #SingleElement #ProblemSolving

📌 Day 2/100 – Remove Element (LeetCode 27)  🔹 Problem:  Given an integer array nums and a value val, remove all instances of that value in-place and return the new length of the array. The order of elements can be changed. 🔹 Approach: Used the two-pointer technique to efficiently modify the array in-place. One pointer iterates through the array, while the other tracks the position to overwrite non-val elements. Returned the position of the second pointer as the new length. 🔹 Key Learning: Strengthened understanding of in-place array manipulation. Improved logic building for pointer movement and conditional overwriting. Learned how to minimize extra space usage while maintaining readability and clarity. Another small yet powerful step toward mastering array-based problems! 💻 🔥 #100DaysOfCode #LeetCode #Java #ProblemSolving #TwoPointers #DSA #CodingJourney

💻 Day 74 of #LeetCode100DaysChallenge Solved LeetCode 18: 4Sum — a challenging problem that enhances array manipulation, two-pointer technique, and handling duplicates. 🧩 Problem: Given an array nums of n integers and a target value, return all unique quadruplets [nums[a], nums[b], nums[c], nums[d]] such that: All indices are distinct The sum of the four numbers equals the target Result can be returned in any order 💡 Approach — Sorting + Two Pointers: 1️⃣ Sort the array to simplify duplicate handling. 2️⃣ Use two nested loops to fix the first two numbers. 3️⃣ Apply the two-pointer technique for the remaining two numbers to find quadruplets that sum to the target. 4️⃣ Skip duplicate elements to ensure uniqueness. 5️⃣ Collect all valid quadruplets in a list. ⚙️ Complexity: Time: O(N³) — two loops + two-pointer scan Space: O(N) — for storing results ✨ Key Takeaways: ✅ Strengthened two-pointer technique for k-sum problems. ✅ Learned efficient strategies for avoiding duplicates in combinatorial results. ✅ Practiced breaking down complex problems into smaller, manageable steps. #LeetCode #100DaysOfCode #Java #TwoPointers #Arrays #4Sum #DSA #ProblemSolving #CodingJourney #WomenInTech