Java Binary Tree Validation & Properties via LeetCode

Day - 90 Binary Tree Maximum Path Sum The problem - Given the root of a binary tree, return the maximum path sum of any non-empty path. A path is defined as any sequence of nodes from some starting node to any node in the tree along the parent-child connections. The path must contain at least one node and does not need to go through the root. The path sum is the sum of the node values in the path. Brute Force - For each node, consider all possible paths starting from that node using DFS, calculate their sums, and track the maximum. This gives O(n²) time complexity as we explore multiple paths from each node with redundant calculations. Approach Used - •) Declare res = {root.val}. •) Call helper function: dfs(root , res). •) Return res[0]. Helper Function - dfs( Treenode node , int[] res) •) If node == null, return 0 (no contribution from null node). •) leftSum = Math.max(0, dfs(node.left, res)), taking max with 0 to ignore negative paths. •) rightSum = Math.max(0, dfs(node.right, res)), taking max with 0 to ignore negative paths. •) Update maximum sum, res[0] = Math.max(res[0], leftSum + rightSum + node.val), this considers path through current node connecting both subtrees. •) Return Math.max(leftSum, rightSum) + node.val, parent can use only one branch left or right. Complexity - Time - O(n), where n = number of nodes. Space - O(h), where h = height of tree. Note - At each node, we consider two scenarios: (1) the maximum path passing through this node (connecting both subtrees), which updates the global maximum, and (2) the maximum path extending from this node to its parent (using only one subtree), which is returned. We use Math.max(0, childSum) to ignore negative contributions, as excluding negative paths yields better sums. #DSA #Java #SoftwareEngineering #InterviewPrep #LearnToCode #CodeDaily #ProblemSolving

🚀 Daily DSA Practice – Day 40 | Path Sum & Backtracking in Binary Trees (Java) Continuing my Data Structures & Algorithms journey, today I focused on path-based tree problems, combining DFS recursion and backtracking to explore root-to-leaf and multi-path scenarios — a key pattern in coding interviews. 📌 Problems Solved (LeetCode): • 112. Path Sum – Checked existence of a root-to-leaf path matching a target sum • 113. Path Sum II – Stored all valid root-to-leaf paths using backtracking • 437. Path Sum III – Counted total paths using prefix-sum optimization with DFS 🎯 Key Learnings: ✔ Difference between existence check vs storing paths vs counting paths ✔ Practical use of backtracking to manage dynamic path lists ✔ Prefix-sum technique for optimizing multi-path calculations ✔ Improved understanding of recursion state management and edge cases These problems highlight how tree + backtracking patterns are widely used in search algorithms, hierarchical data analysis, and optimization tasks, making them highly relevant for product-based company interviews. #DSA #LeetCode #Java #BinaryTree #Backtracking #DFS #PathSum #ProblemSolving #InterviewPreparation #BackendDeveloper #SoftwareEngineer

🚀 #100DaysOfCode | Day 36 📌 LeetCode – Path Sum Today I solved the Path Sum problem using a recursive Depth-First Search (DFS) approach. Given a binary tree and a target sum, determine whether there exists a root-to-leaf path such that the sum of all node values equals the target. 💡 Approach: ✔ If the node is null, return false. ✔ If it's a leaf node, check whether the remaining sum equals the node value. ✔ Recursively subtract the current node value from targetSum. ✔ Check both left and right subtrees. ✔ If either returns true → path exists. ⏱ Complexity: Time Complexity: O(n) Space Complexity: O(h) — height of the tree Binary tree problems are all about mastering recursion and understanding base cases clearly. #Java #LeetCode #DSA #BinaryTree #Recursion #ProblemSolving

Today I worked on removing duplicates from a sorted array in-place while maintaining the relative order of elements. The task was not to create a new array, but to modify the existing one and return the count of unique elements. Since the array is already sorted, duplicates appear consecutively. This makes it possible to solve the problem efficiently using a two-pointer approach. I maintained one pointer to track the position of the next unique element and another pointer to iterate through the array. Whenever a new distinct element was found, it was placed at the correct position, and the unique index pointer was incremented. This ensures: The array is modified in-place. The relative order remains unchanged. No extra space is used beyond constant variables. Time Complexity: O(n) Space Complexity: O(1) Key takeaway: When data is sorted, problems involving duplicates or frequency often become much simpler. Recognizing structural properties of input data is crucial for writing optimal solutions. Day 8 completed. Staying consistent and focusing on fundamentals. #100DaysOfLeetCode #TwoPointers #Java #DataStructures #ProblemSolving #Consistency

Day 6 of Daily DSA 🚀 Solved LeetCode 977: Squares of a Sorted Array Approach: Used the two-pointer technique to compare squares from both ends of the array and build the result from back to front. This avoids extra sorting and keeps the solution optimal. Complexity: • Time: O(n) • Space: O(n) LeetCode Stats: • Runtime: 1 ms (Beats 99.80%) • Memory: 47.21 MB (Beats 74.22%) This problem reinforced how understanding data patterns can help eliminate unnecessary operations like sorting. #DSA #LeetCode #Java #TwoPointers #ProblemSolving #Consistency #100DaysOfCode

Day 18 of My Daily DSA Challenge Today I solved the "Merge Two Sorted Lists" problem. This problem strengthened my understanding of linked list manipulation and recursive thinking. The main challenge was carefully comparing nodes and attaching them in sorted order while maintaining proper references between nodes. Key learnings: Recursive solutions can make linked list problems more intuitive. Base cases are critical in recursion to avoid infinite calls. Handling null conditions correctly prevents runtime errors. Problems like this remind me that data structures are not just about code syntax, but about understanding how data moves and connects internally. Consistency is slowly building stronger logic and confidence with each passing day. #DSA #Java #LinkedList #ProblemSolving #CodingJourney #Consistency

Day - 87 Binary Tree Level Order Traversal The problem - Given the root of a binary tree, return the level order traversal of its nodes' values (i.e., from left to right, level by level). Each level should be represented as a separate list. Brute Force - Use recursive DFS to traverse the tree while tracking depth. Store nodes at each depth level in separate lists. This gives O(n) time but requires complex depth tracking and is less intuitive than an iterative approach. Approach Used - •) Create res = new ArrayList<>(), queue = new ArrayDeque<>(). •) If root == null, return empty res. •) Add root to queue. •) While queue is not empty, 1 - Get current level size: size = queue.size(). 2 - Create list = new ArrayList<>(). 3 - While size > 0, - Poll node from queue, node = queue.poll(). - ⁠If node.left != null, add to queue: queue.add(node.left). - ⁠If node.right != null, add to queue: queue.add(node.right). - ⁠Add node value to current level: list.add(node.val). - ⁠Decrement size—. 4 - Add current level to result, res.add(list). •) Return res. Complexity - Time - O(n), where n = number of nodes. Space - O(w), where w = maximum width of tree. Note - Use BFS with a queue to traverse level by level. By capturing the queue size at the start of each iteration, we know exactly how many nodes belong to the current level. Process all nodes in that level, adding their children to the queue for the next level. This naturally groups nodes by level without needing depth tracking. #DSA #Java #SoftwareEngineering #InterviewPrep #LearnToCode #CodeDaily #ProblemSolving

✂️ DSA Practice — Remove All Occurrences of a Character (Recursive Approach) Today I solved Remove all occurrences of a character in a string using a recursive approach, focusing on careful index handling and in-place modification. 🔍 Key Learnings Recursion is useful even for string manipulation problems. When modifying a string in-place, index management is critical. After deletion, characters shift left — so the index should not advance. Clear base cases prevent infinite recursion. 🧠 Why This Problem Matters Strengthens understanding of recursion with mutable data structures. Helps build intuition for string traversal and modification. Common problem to test attention to detail and edge cases. 📌 Final Takeaway This problem highlights that recursion isn’t just about breaking problems down — it’s also about understanding how data changes during execution. #dsa #recursion #strings #problemSolving #codingpractice #java #datastructures #interviewpreparation #algorithms #100DaysOfCode #softwareengineering

🔥 Day 309 – Daily DSA Challenge! 🔥 Problem: 🔁 Permutations II Given an array nums that may contain duplicate numbers, return all unique permutations in any order. 💡 Key Insights: 🔹 This is a backtracking problem with an extra twist — duplicates. 🔹 Sorting the array upfront is the key to handling duplicates cleanly. 🔹 Use a used[] boolean array to track which elements are already in the current permutation. 🔹 The golden rule to skip duplicates 👇     👉 If the current number is the same as the previous one and the previous one is not used, skip it. 🔹 This ensures we only generate unique permutations. ⚡ Optimized Plan: ✅ Sort the input array ✅ Use backtracking to build permutations ✅ Track used elements with a boolean array ✅ Add permutation to result when its size equals nums.length ✅ Skip duplicates using:     if (i > 0 && nums[i] == nums[i - 1] && !used[i - 1]) continue; ✅ Backtrack after each recursive call ✅ Time Complexity: O(n! × n) (due to copying permutations) ✅ Space Complexity: O(n) (recursion stack + used array) 💬 Challenge for you: 1️⃣ Why does the condition !used[i - 1] matter for avoiding duplicates? 2️⃣ How would this solution change if all numbers were unique? 3️⃣ Can you generate permutations iteratively instead of using recursion? #DSA #Day309 #LeetCode #Permutations #Backtracking #Recursion #Java #ProblemSolving #KeepCoding #100DaysOfCode

🚀 Day 31 of #100DaysOfCode – Binary Tree Today I solved an interesting Binary Tree problem: 👉 Problem: Given the root of a binary tree, return the sum of every node’s tilt. 🔎 Concept Used: Postorder Traversal (DFS) Recursion Tree Subtree Sum Calculation 💡 Key Idea: For each node: Calculate sum of left subtree Calculate sum of right subtree Compute tilt = |leftSum - rightSum| Add tilt to a global variable By using Postorder Traversal (Left → Right → Root), we can compute subtree sums and tilt in a single traversal. 📈 Time Complexity: O(n) 📦 Space Complexity: O(h) (height of tree) This problem helped me strengthen my understanding of: ✔️ Tree recursion ✔️ Depth First Search ✔️ Writing clean recursive logic Consistency is key. One problem at a time. 💪 #Java #DataStructures #BinaryTree #DSA #CodingChallenge #LearningJourney #100DaysOfCode