Count Good Nodes in Binary Tree with Java LeetCode Solution

🚀 Mastering Java Through LeetCode 🧠 Day 32 Today I solved an Easy-level Tree problem that strengthened my understanding of Recursion + Depth Calculation — a fundamental concept for tree-based problems 📌 LeetCode Problem Solved: Q.104. Maximum Depth of Binary Tree 💭 Problem Summary: Given a binary tree, the task is to find the maximum depth — i.e., the number of nodes along the longest path from root to leaf. 🧠 Approach (Optimal): Instead of iterating level by level, I used a clean recursive approach: ✔️ If node is null → return 0 ✔️ Recursively calculate left subtree depth ✔️ Recursively calculate right subtree depth ✔️ Return 1 + max(left, right) ⚡ Key Learning: Recursion makes tree problems much simpler when you think in terms of “what should each function return for a node?” Complexity: Time: O(n) Space: O(h) Takeaway: Tree problems become easier once you master recursion and start recognizing patterns. Consistency is the key — showing up every day #Day32 #LeetCode #Java #DSA #CodingJourney #Recursion #BinaryTree #100DaysOfCode #SoftwareEngineering

Day 31 of #50DaysLeetCode Challenge 💻🔥 Today I solved the “Permutations” problem using Java. 🔹 Problem: Given an array of distinct integers, return all possible permutations. 🔹 Reality check: If you don’t understand recursion properly, this problem will expose you. There’s no shortcut here. 🔹 Approach (Backtracking): Fix one element at a time Swap it with every possible choice Recurse for the remaining positions Backtrack (undo the swap) to explore other possibilities 🔹 Key Insight: This isn’t about generating values — it’s about exploring a decision tree. Every level = a position in the array Every branch = a choice 🔹 Time Complexity: O(n!) — and that’s unavoidable 📌 What I learned: Backtracking is not optional for DSA. If you try to avoid it, you’ll get stuck on a whole category of problems. Stop memorizing patterns blindly. Understand why the recursion works. #Day25 #LeetCode #Java #Backtracking #DSA #CodingChallenge #ProblemSolving

🚀 DSA Journey — LeetCode Practice 📌 Problem: Maximum Depth of Binary Tree 💻 Language: Java 🔹 Approach: To solve this problem, I used Breadth-First Search (BFS) with a Queue to perform level-order traversal of the binary tree. • Start by adding the root node to the queue • Traverse the tree level by level • For each level, process all nodes currently in the queue • Add left and right children of each node to the queue • Increment the level count after completing each level 📌 Logic Insight: Each iteration of the outer loop represents one level of the tree, which directly helps in calculating the maximum depth. ⏱ Time Complexity: O(n) 🧩 Space Complexity: O(n) (queue storage in worst case) 💡 Key Learning: This problem helped me understand how level-order traversal (BFS) can be used not just for traversal, but also for solving structural problems like finding tree depth efficiently. It also reinforced the importance of queue-based processing in trees. #DSA #Java #LeetCode #BinaryTree #BFS #Queue #CodingJourney #ProblemSolving #LearningInPublic #TreeTraversal

🚀 Mastering Java Through LeetCode 🧠 Day 17 of My DSA Journey Today I solved another problem from the LeetCode list to improve my understanding of arrays and prefix sum concepts. 📌 LeetCode Problem Solved Today: Q.1732. Find the Highest Altitude In this problem, a biker starts a road trip from altitude 0, and we are given an array that represents the gain or loss in altitude between points. The task is to find the highest altitude reached during the trip. Method 1: Using ArrayList (My 1st Approach) I stored all altitudes step by step in an ArrayList and then used Collections.max() to find the highest altitude. Method 2: Optimized Approach (My Second Approach Without Extra Space) Instead of storing all values, we can directly track the maximum altitude while iterating. 💻 Optimized Java Solution class Solution { public int largestAltitude(int[] gain) { int altitude = 0; int maxAltitude = 0; for (int g : gain) { altitude += g; maxAltitude = Math.max(maxAltitude, altitude); } return maxAltitude; } } Example: Input: gain = [-5,1,5,0,-7] Altitudes formed: [0, -5, -4, 1, 1, -6] Highest altitude = 1 Consistent practice is helping me strengthen my DSA and problem-solving skills step by step. #LeetCode #DSA #Java #CodingJourney #ProblemSolving #ArrayList #100DaysOfCode #SPPU #EngineeringLife #TechCommunity #CDAC

Mastering Java through LeetCode Day 37 of #LeetCode Challenge Today I solved Lowest Common Ancestor of a Binary Tree Problem Insight: The goal is to find the lowest node in a binary tree that has both given nodes as descendants (a node can be a descendant of itself). Approach I used: Used DFS + Recursion If the current node is null or matches one of the targets → return it Recursively search left and right subtrees If both sides return non-null → current node is the LCA ⚡ Key Learning: Understanding how recursion propagates results upward is crucial for solving tree problems efficiently. ⏱️ Complexity: Time: O(n) Space: O(h) Consistency > Intensity Improving problem-solving skills one day at a time! #DataStructures #Algorithms #Java #CodingJourney #SoftwareEngineering #OpenToWork #LeetCode #LearningInPublic

🚀 DSA Journey — LeetCode Practice 📌 Problem: Binary Tree Preorder Traversal (LeetCode 144) 💻 Language: Java 🔹 Approach: To solve this problem, I used Depth-First Search (DFS) with Recursion to perform preorder traversal of the binary tree. • Visit the root node first • Store the root value in the result list • Recursively traverse the left subtree • Recursively traverse the right subtree • Follow Preorder pattern: Root → Left → Right This approach works efficiently because recursion naturally follows the preorder traversal structure. ⏱ Time Complexity: O(n) 🧩 Space Complexity: O(n) (including recursion stack) 📖 Key Learning: This problem strengthened my understanding of DFS, recursion, and tree traversal patterns. It also reinforced the preorder pattern (Root → Left → Right), which is a fundamental concept used in many tree-based problems 💡 #DSA #Java #LeetCode #ProblemSolving #CodingJourney #LearningInPublic #BinaryTree #DFS #Recursion #TreeTraversal

🚀 Mastering Java Through LeetCode 🧠 Day 22 of My DSA Journey Today I solved an interesting matrix-based problem that improved my understanding of arrays and comparison logic. 📌 LeetCode Problem Solved Today: 2352 – Equal Row and Column Pairs Problem Statement: Given an n x n matrix, find how many pairs (row, column) are exactly the same. A pair is valid only if both contain the same elements in the same order. 🧠 Key Idea: Compare each row with every column Check element-by-element equality Count all matching pairs 🔍 Example: Input: [[3,2,1], [1,7,6], [2,7,7]] Output: 1 Matching Pair: Row 2 = Column 1 → [2,7,7] ⚙️ Approach: Traverse all rows Build each column dynamically Compare row[i][k] with column[k][j] If all elements match → increment count ⏱️ Time Complexity: O(n³) (Optimized solution using HashMap possible in O(n²)) What I Learned: Matrix traversal techniques Row vs Column comparison logic Importance of nested loops in grid problems 🔥 Consistency is the key! Every day one problem closer to my goal of becoming a Software Engineer #LeetCode #DSA #Java #CodingJourney #100DaysOfCode #SoftwareEngineer #ProblemSolving #Learning #Tech

🚀 DSA Journey — LeetCode Practice 📌 Problem: Same Tree 💻 Language: Java 🔹 Approach: To solve this problem, I used Recursion to compare both binary trees node by node. • If both nodes are null → return true • If one node is null and the other is not → return false • If node values are different → return false • Recursively compare left subtrees • Recursively compare right subtrees • If both left and right comparisons return true → both trees are identical This approach works because each subtree is itself a smaller version of the same problem, making recursion a natural fit. ⏱ Time Complexity: O(n) 🧩 Space Complexity: O(h) (where h = height of tree, worst case O(n)) 📖 Key Learning: This problem strengthened my understanding of tree traversal, recursion, and base case handling. It also reinforced how breaking a problem into smaller subproblems makes tree problems much easier to solve 💡 #DSA #Java #LeetCode #ProblemSolving #CodingJourney #LearningInPublic #BinaryTree #Recursion

🚀 Mastering Java Through LeetCode 🧠 Day 20 of My DSA Journey Today I solved another problem from the LeetCode 75 list to improve my understanding of HashMap and HashSet concepts and strengthen my problem-solving skills. 📌 LeetCode Problem Solved Today: Q.1207 – Unique Number of Occurrences 💡 Problem Statement: Given an integer array arr, return true if the number of occurrences of each value in the array is unique, otherwise return false. 🧩 Example 1: Input: [1,2,2,1,1,3] Output: true 🧩 Example 2: Input: [1,2] Output: false Key Learning: Today I learned how to efficiently solve problems using Hashing techniques: ✔️ Use HashMap to count frequency of each number ✔️ Use HashSet to check if frequencies are unique ✔️ If any frequency repeats → return false 🧠 Approach: 1️⃣ Traverse array and store frequency using getOrDefault() 2️⃣ Traverse map values 3️⃣ Check duplicates using HashSet ⏱️ Complexity: Time Complexity: O(n) Space Complexity: O(n) This problem helped me understand how frequency counting + uniqueness checking works in real interview scenarios. Consistency is the key — solving problems daily to become a better software engineer 💻 #LeetCode #Java #DSA #ProblemSolving #CodingJourney #LearningInPublic #SoftwareDevelopment #Programming #Coding #Tech #Developers #100DaysOfCode #TechCareer #InterviewPreparation #HashMap #HashSet #CodingPractice #PGCP #CDAC #LeetCode75

🚀 DSA Journey — LeetCode Practice 📌 Problem: Binary Tree Inorder Traversal (LeetCode 94) 💻 Language: Java 🔹 Approach: To solve this problem, I used Depth-First Search (DFS) with Recursion to perform inorder traversal of the binary tree. • Recursively traverse the left subtree • Visit the root node and store its value • Recursively traverse the right subtree • Follow Inorder pattern: Left → Root → Right This approach works efficiently because recursion naturally follows the inorder traversal structure. ⏱ Time Complexity: O(n) 🧩 Space Complexity: O(n) (including recursion stack) 📖 Key Learning: This problem strengthened my understanding of DFS, recursion, and tree traversal patterns. It also reinforced the inorder pattern (Left → Root → Right), which is a fundamental concept used in many tree-based problems 💡 #DSA #Java #LeetCode #ProblemSolving #CodingJourney #LearningInPublic #BinaryTree #DFS #Recursion #TreeTraversal