Binary Tree Level Sum with BFS

🗓 Day 66 / 100 – #100DaysOfLeetCode 📌 Problem 865: Smallest Subtree with All the Deepest Nodes Today’s problem focused on binary tree depth analysis. The goal was to find the smallest subtree that contains all the deepest nodes in the tree. 🧠 My Approach: Used Depth-First Search (DFS) to compute information bottom-up. For each node, tracked: the maximum depth reachable from that node, and the candidate subtree root that contains all deepest nodes. Compared depths of left and right subtrees: If both sides have the same depth → the current node is the answer. Otherwise, propagated the deeper side upward. Returned the node that satisfies the condition for all deepest nodes. This approach cleanly combines depth calculation with subtree selection in a single traversal. 💡 Key Learning: This problem reinforced: ✔ how returning multiple values from DFS simplifies logic ✔ thinking bottom-up for tree optimization problems ✔ identifying the exact node where depths converge Tree problems often become elegant once the right recursive structure is identified 🌳🚀 #100DaysOfLeetCode #LeetCodeChallenge #Python #ProblemSolving #BinaryTree #DFS #TreeTraversal #Algorithms #DSA #CompetitiveProgramming #SoftwareEngineering #CodingJourney #DeveloperJourney #LearningInPublic #TechStudent #CareerGrowth #Programming #KeepLearning

Day 4 of DSA Practice : Today I learned about Bubble Sort and understood how we can optimize it step by step. 🔹 Approaches Learned: Basic Bubble Sort: O(n²) Optimized Bubble Sort (Early Exit using a flag): Best Case O(n), Worst Case O(n²) ✅ Key Idea (Bubble Sort): We repeatedly compare adjacent elements and swap them if they’re in the wrong order. After each pass, the largest element “bubbles up” to the end of the array. 🚀 Optimization (Early Exit): If in any pass no swaps happen, the array is already sorted — so we stop early. ⚡ Complexity: Time: Worst O(n²), Best O(n) (already sorted with optimization) Space: O(1) This sorting method is great for learning sorting basics and understanding swapping-based sorting. #DSA #Programming #CompetitiveProgramming #Java #Cplusplus #Python #Learning

🗓 Day 64 / 100 – #100DaysOfLeetCode 📌 Problem 1339: Maximum Product of Splitted Binary Tree Today’s problem combined tree traversal with optimization logic. The task was to split a binary tree into two subtrees by removing exactly one edge, such that the product of the sums of the two resulting subtrees is maximized. 🧠 My Approach: First, computed the total sum of all nodes in the tree. Used a post-order DFS traversal to calculate the sum of each subtree. For every subtree: Considered it as one part after the split. The other part would have sum: total_sum − subtree_sum Calculated the product of these two values. Tracked the maximum product across all possible splits. Returned the result modulo 109+710^9 + 7109+7, as required. Post-order traversal works perfectly here because subtree sums must be known before evaluating the split. 💡 Key Learning: This problem reinforced: ✔ how post-order DFS is ideal for subtree-based calculations ✔ combining traversal with optimization criteria ✔ thinking globally (total sum) while evaluating local decisions (each split) A great example of how tree problems often require two passes: one for data collection and one for optimization. Another strong tree-based DP-style problem completed 🌳🚀 #100DaysOfLeetCode #LeetCodeChallenge #Python #ProblemSolving #BinaryTree #DFS #TreeDP #Algorithms #DSA #CompetitiveProgramming #SoftwareEngineering #CodingJourney #DeveloperJourney #LearningInPublic #TechStudent #CareerGrowth #Programming #KeepLearning

✅ Day 10 of 100 Days LeetCode Challenge Problem: 🔹 #1448 – Count Good Nodes in Binary Tree 🔗 https://lnkd.in/gDfr48AK Concepts Used: 🔹 Binary Tree 🔹 Depth-First Search (DFS) 🔹 Recursion 🔹 Path-based State Tracking Approach Summary: 🔹 Used DFS to traverse the tree from root to leaves. 🔹 Maintained the maximum value (maxi) seen so far along the path. 🔹 A node is considered good if its value is greater than or equal to maxi. 🔹 Updated maxi at each step and accumulated the count recursively. Key Insight: 🔹 “Good nodes” depend on the path from the root, not the entire tree. 🔹 Passing state (maximum so far) through recursion avoids extra storage. 🔹 This leads to a clean and efficient solution with optimal traversal. #LeetCode #100DaysOfLeetCode #Day10 #DSA #Daily #Programming #ProblemSolving #Python #CodingJourney #TechCareers

✅ Day 7 of 100 Days LeetCode Challenge Problem: 🔹 #199 – Binary Tree Right Side View 🔗 https://lnkd.in/ghC43a-T Concepts Used: 🔹 Binary Tree 🔹 Breadth-First Search (BFS) 🔹 Level Order Traversal 🔹 Queue (Deque) Approach Summary: 🔹 Used level-order traversal to process the tree level by level. 🔹 For each level, tracked the number of nodes present. 🔹 Captured the value of the last node at each level (rightmost). 🔹 Used a queue to maintain traversal order efficiently. Key Insight: 🔹 The right side view consists of the last node visible at every level. 🔹 BFS is ideal when problems require level-wise processing. 🔹 Identifying patterns in traversal order simplifies tree problems. #LeetCode #DataStructures #Algorithms #SoftwareEngineering #SoftwareDeveloper #ProblemSolving #Programming #ComputerScience #TechCareers #100DaysOfCode #DailyCoding #Consistency #LearningInPublic #Python #TechCommunity

🚀 #DAY74 LeetCode Problem #1200 – Minimum Absolute Difference 🧩 Problem Summary Given a list of distinct integers, the goal is to find all element pairs whose absolute difference is the minimum possible and return them in sorted order. 🧠 How It Works First, sort the array to bring close values together Scan once to compute the minimum difference between adjacent elements Scan again to collect all pairs that match this minimum difference This approach leverages the fact that in a sorted array, the smallest difference must occur between neighboring elements. 📘 What I Learned ✔ Why sorting simplifies difference-based problems ✔ How breaking the task into two passes improves clarity ✔ Turning mathematical observations into efficient logic ✔ Writing clean and readable solutions even when performance isn’t maxed 📊 Performance ⏱ Runtime: 95 ms 💾 Memory: 21.57 MB ✅ 38 / 38 testcases passed 📌 Small optimizations, big clarity — consistency is the real win. #LeetCode #DSA #Algorithms #ProblemSolving #Python #CodingPractice #DataStructures #TechJourney #100DaysOfDSA #LearningByDoing #Consistency #InterviewPrep #CompetitiveProgramming

Problem: Print Elements of a Linked List Concepts: Linked List Traversal | Pointers | Iteration Difficulty: Easy Problem Summary: Given the head of a singly linked list, traverse the list and print the data of each node line by line. If the head is NULL, nothing should be printed. This problem focuses on understanding how to move through nodes using pointers and access data stored in each node. Key Learnings: A linked list is traversed using a temporary pointer that starts at the head Each node stores both data and a next pointer Traversal continues until the pointer becomes NULL Proper pointer movement is essential to avoid infinite loops GitHub Link:https://lnkd.in/dfxDCKdq #Day40 #DSA #LinkedList #ProblemSolving #DataStructures #Coding #Python #Cplusplus #LearningInPublic #50DaysChallenge #TechJourney 

Python with DSA — Day 33 What I worked on: Prime checks: moved from naive divisibility to the √n optimization and the 6k±1 rule to cut unnecessary iterations. Time complexity intuition: compared O(n) vs O(√n) for primality tests; saw how early exits change best/worst cases. Clean loops & edge cases: handled n <= 1, negative inputs, and printed primes from 1–100 with a tight loop. Key snippet (conceptual): Idea: Only test divisors up to √n; if none divide, the number is prime. #Day33 #PythonWithDSA #DataStructures #DSAJourney #ProblemSolving #PythonProgramming #SoftwareEngineer

🚀 #DAY75 of #100DayofDSA Challenge LeetCode Problem #1200 – Minimum Absolute Difference 🧩 Problem Summary Given a list of distinct integers, the goal is to find all element pairs whose absolute difference is the minimum possible and return them in sorted order. 🧠 How It Works First, sort the array to bring close values together Scan once to compute the minimum difference between adjacent elements Scan again to collect all pairs that match this minimum difference This approach leverages the fact that in a sorted array, the smallest difference must occur between neighboring elements. 📘 What I Learned ✔ Why sorting simplifies difference-based problems ✔ How breaking the task into two passes improves clarity ✔ Turning mathematical observations into efficient logic ✔ Writing clean and readable solutions even when performance isn’t maxed 📊 Performance ⏱ Runtime: 95 ms 💾 Memory: 21.57 MB ✅ 38 / 38 testcases passed 📌 Small optimizations, big clarity — consistency is the real win. #LeetCode #DSA #Algorithms #ProblemSolving #Python #CodingPractice #DataStructures #TechJourney #100DaysOfDSA #LearningByDoing #Consistency #InterviewPrep #CompetitiveProgramming

🚀 𝟲𝟬 𝗗𝗮𝘆𝘀 𝗼𝗳 𝗖𝗼𝗱𝗶𝗻𝗴 | 𝗗𝗦𝗔 𝘅 𝗥𝗲𝗮𝗹 𝗪𝗼𝗿𝗹𝗱 𝗣𝗿𝗼𝗷𝗲𝗰𝘁𝘀 #Day27 | 𝗙𝗶𝗹𝗲 𝗣𝗲𝗿𝗺𝗶𝘀𝘀𝗶𝗼𝗻 𝗖𝗵𝗲𝗰𝗸𝗲𝗿 Built a File Permission Checker using Tree Traversals (DFS & BFS) to scan hierarchical file systems efficiently. Focused on: • Depth-first and breadth-first traversal • Tree-based file system modeling • Permission filtering logic Understanding how operating systems traverse directories 📌 𝗖𝗼𝗱𝗲 𝗮𝗻𝗱 𝗱𝗼𝗰𝘂𝗺𝗲𝗻𝘁𝗮𝘁𝗶𝗼𝗻: https://lnkd.in/gxzGJ4nB Feedback and suggestions are welcome. #DSA #TreeTraversal #DFS #BFS #Python #60DaysOfCoding #LearningInPublic #SoftwareEngineering