Java LeetCode 508 Most Frequent Subtree Sum

Day 91/100 – #100DaysOfCode 🚀 | #Java #BinaryTree #BFS ✅ Problem Solved: Find Largest Value in Each Tree Row (LeetCode) 🧩 Problem Summary: Given the root of a binary tree, return an array containing the largest value in each level (row) of the tree. 💡 Approach Used: ✔ Used Breadth-First Search (Level Order Traversal) ✔ Process the tree level by level using a queue For each level: Initialize maxValue to the smallest possible integer Traverse all nodes at that level Update maxValue Add it to the result list ⚙ Time Complexity: O(N) 📦 Space Complexity: O(W) (where W = maximum width of the tree) ✨ Takeaway: Level-order traversal is ideal when problems require row-wise processing in trees — clean, intuitive, and efficient. #Java #LeetCode #BinaryTree #BFS #100DaysOfCode #CodingChallenge

Day 89/100 – #100DaysOfCode 🚀 | #Java #BinaryTree #BFS ✅ Problem Solved: Find Bottom Left Tree Value (LeetCode 513) 🧩 Problem Summary: Given the root of a binary tree, return the leftmost value in the last row of the tree. 💡 Approach Used: ✔ Used Level Order Traversal (BFS) ✔ Traverse the tree level by level ✔ For each level, store the first (leftmost) node value ✔ The value from the last level is the answer This guarantees we always capture the correct bottom-left value. ⚙ Time Complexity: O(N) 📦 Space Complexity: O(N) (queue for BFS) ✨ Takeaway: Level-order traversal is ideal when problems involve row-wise processing or depth-based values in trees. #Java #LeetCode #BinaryTree #BFS #100DaysOfCode #CodingChallenge

Day 57/100 of #100DaysOfCode 🚀 “Count Good Nodes in a Binary Tree” problem on LeetCode.. A node is considered good if there is no node with a greater value on the path from the root to that node. Approach: ->Traversed the tree using recursion ->Passed the maximum value seen so far along the root-to-node path ->Compared the current node’s value with the max: ->If node.val >= max, it’s a good node ->Updated the max value before going deeper ->Recursively counted good nodes in left and right subtrees ->Summed up the counts to get the final result #Day57 #100DaysOfCode #LeetCode #BinaryTree #DFS #Recursion #Java #DSA #ProblemSolving #LearningEveryDay

When I first learned Tree data structures in Java, I felt lost. Arrays were easy. Lists were predictable. Everything was linear. Then Trees showed up.      1      / \     2   3     / \ / \   4 5 6 7 I just don't know how to read this. If you’ve ever felt the same confusion, I wrote a detailed breakdown, starting from counting nodes, understanding levels, all the way to inOrder traversal. 👉 Read the full explanation on my website here: https://lnkd.in/g6kJjRTC #Java #DataStructures #BinaryTree #SoftwareEngineering #BackendDevelopment

#200DaysOfCode – Day 108 Combination Sum III Problem:- Combination Sum III Task:- Find all valid combinations of k numbers that sum up to n, using only numbers from 1 to 9, where: Each number is used at most once No duplicate combinations are allowed Example: Input: k = 3, n = 7 Output: [[1, 2, 4]] My Approach:- Used Backtracking (DFS) to explore all possible combinations. Started from a given number to avoid duplicates. Stopped recursion when: The combination size exceeded k The sum became negative Added the combination to the result only when: Exactly k numbers were chosen The sum became 0 Time Complexity:- Exponential (bounded due to range 1–9) Space Complexity:- O(k) (recursive stack + temporary list) Backtracking may look complex at first, but with clear base conditions and pruning, it becomes a powerful and elegant tool for solving combination problems efficiently. #takeUforward #200DaysOfCode #Java #ProblemSolving #LeetCode #Backtracking #Recursion #DSA #CodingJourney #CodeNewbie

Day 80/100 – #100DaysOfCode 🚀 | #Java #BinarySearchTree #DFS ✅ Problem Solved: Find Mode in Binary Search Tree (LeetCode) 🧩 Problem Summary Given the root of a Binary Search Tree, return all the mode(s) — the value(s) that appear most frequently in the tree. 📌 Note: BST property → inorder traversal gives sorted order There may be multiple modes 💡 Approach Used ✔ Use inorder traversal (DFS) to process values in sorted order ✔ Track: prev → previous node value count → current frequency maxCount → highest frequency seen so far ✔ Logic: If current value == prev → increment count Else → reset count to 1 Update result list when: count > maxCount → clear list & add value count == maxCount → add value This avoids extra space like HashMaps by leveraging BST properties. ⚙ Time Complexity: O(N) 📦 Space Complexity: O(H) (recursion stack) ✨ Takeaway Understanding tree properties (like sorted inorder traversal in BST) can eliminate unnecessary data structures and lead to cleaner solutions. #Java #LeetCode #BST #DFS #TreeTraversal #100DaysOfCode #CodingChallenge

DSA in real API responses 👇 • Pagination → Array slicing • Sorting → List + Comparator • Filtering → Streams / loops Arrays are not basic. They are everywhere in production. #DSA #Backend #Java

🚀 DSA Day 3 | Arrays & Prefix Sum (Java) Today’s focus was on Prefix Sum, an important array technique that helps optimize range sum queries efficiently. ✅ What I learned: How to build a prefix sum array Difference between in-place and extra array prefix sums How prefix sum reduces time complexity from O(n) to O(1) for range queries Solved multiple practice problems to strengthen logic 🧠 Key Insight: Pre-computation makes problem solving faster and cleaner. Consistency over motivation. One day at a time 💪 #DSA #Java #PrefixSum #Arrays #CodingJourney #LearningEveryDay #100DaysOfCode

Day 97/100 – #100DaysOfCode 🚀 | #Java #Strings #Logic ✅ Problem Solved: Longest Uncommon Subsequence I (LeetCode) 🧩 Problem Summary: Given two strings, find the length of the longest uncommon subsequence — a subsequence that appears in one string but not in the other. 💡 Approach Used: ✔ Observational / logical approach ✔ If both strings are equal, no uncommon subsequence exists ✔ If they are different, the longer string itself is the answer Why it works: A string is always a subsequence of itself If strings differ, the longer one cannot be a subsequence of the shorter ⚙ Time Complexity: O(1) 📦 Space Complexity: O(1) ✨ Takeaway: Some problems look like DP but are solved with pure logic. Always check for simple observations before overengineering. #Java #LeetCode #Strings #Logic #100DaysOfCode #CodingChallenge

📅 Day 73 of #100DaysOfLeetCode 🧩 Problem: 3314. Construct the Minimum Bitwise Array I 📊 Difficulty: Easy 🧠 Key Insight For each prime number nums[i], we need to find the smallest non-negative integer x such that: x | (x + 1) == nums[i]. If no such value exists, the answer should be -1. ⚙️ Approach Initialize the answer array with -1 For each number nums[i]: Try all values of x from 0 to nums[i] - 1 Check if x | (x + 1) equals nums[i] As soon as a valid x is found, store it and stop searching If no valid value is found, keep -1 for that index ⏱ Complexity Time: O(n × max(nums[i])) Space: O(1) #LeetCode #Java #ProblemSolving #CodingChallenge #100DaysOfCode #DSA #LearningEveryday