LeetCode 739: Monotonic Stack Solution

Fixing an Unbalanced Tree the Systematic Way 🌳 Solved LeetCode 1382 - Balance a Binary Search Tree today. The approach was clean and systematic: -Use inorder traversal to extract nodes in sorted order -Pick the middle element as the root -Recursively build left and right subtrees This guarantees a height-balanced BST without complex rotations. Key takeaway: Sometimes the best way to fix a structure is to rebuild it with the right invariants, not patch it incrementally. This problem nicely connected traversal, sorting, and divide-and-conquer thinking. #LeetCode #DSA #BinarySearchTree #TreeTraversal #DivideAndConquer #JavaScript #ProblemSolving #LearnInPublic

When One Path Isn’t Enough: Tracking All Valid Paths 🌳 Solved LeetCode 113 - Path Sum II today. Unlike Path Sum I, this version requires returning all root-to-leaf paths that match the target sum. The key shift: -Use recursion to explore paths -Maintain a current path array -Apply backtracking (push before recursion, pop after) Key takeaway: Whenever a problem asks for all combinations or all paths, think backtracking + state cleanup. This one strengthened my understanding of recursion with state management. #LeetCode #DSA #BinaryTree #Backtracking #Recursion #JavaScript #ProblemSolving #LearnInPublic

When Trees Meet Two Pointers: A Clean Twist on Two Sum 🌳 Solved LeetCode - Two Sum IV (Input is a BST) today. The approach clicked once I combined two ideas: Inorder traversal to leverage the BST’s sorted order Two-pointer technique to efficiently search for the target sum By converting the tree into a sorted sequence, the problem reduces to a classic two-sum pattern. Key takeaway: Many tree problems become simpler when you translate them into array patterns, the trick is knowing when it’s safe to do so. Building stronger cross-pattern intuition in DSA. #LeetCode #DSA #BinarySearchTree #TwoPointers #TreeTraversal #JavaScript #ProblemSolving #LearnInPublic

Two Ways to Reach the Same Sum 🌳 Solved LeetCode 112 - Path Sum using two recursive approaches. First approach: Accumulator pattern → Keep passing the running sum down the tree. Second approach: Reducing pattern → Subtract the current node value from the target and pass the reduced value forward. Both work, but they shape your thinking differently. Key takeaway: -Tree recursion isn’t just about correctness, it’s about choosing the right mental model. -Accumulate forward or reduce the goal backward. -Understanding both strengthens recursive intuition. #LeetCode #DSA #BinaryTree #Recursion #JavaScript #ProblemSolving #LearnInPublic

Solved another important array problem from LeetCode today on JDCodebase 🚀 ✔️ Find Pivot Index (LeetCode 724) This problem looks simple at first… but it teaches a powerful concept. You’ll learn: • What “strictly left” and “strictly right” really mean • How to build the brute-force approach (O(n²)) • How to optimize it using Prefix Sum / Running Sum (O(n)) • How to think step-by-step like an interviewer Understanding this problem properly strengthens your array fundamentals and builds clarity around prefix sum techniques. Strong basics = Strong problem-solving 💪 If you're starting your DSA journey with JavaScript, this will help you level up your thinking. 🎥 Watch here: 👉 https://lnkd.in/g2Ryv78w #DSA #LeetCode #JavaScript #CodingPractice #ProblemSolving #JDCodebase

Order Reveals the Answer: Let the BST Sort for You 🌳 Solved LeetCode - Kth Smallest Element in a BST today. The key insight was recognizing that inorder traversal of a BST produces sorted values. Once the tree is traversed in order, the problem reduces to picking the (k-1)th element from the sorted sequence. Key takeaway: Many BST problems aren’t about inventing new logic, they’re about using the guarantees the data structure already gives you. This problem reinforced how traversal choice can simplify complex-looking questions into straightforward solutions. #LeetCode #DSA #BinarySearchTree #TreeTraversal #JavaScript #ProblemSolving #LearnInPublic

Rotate Without Extra Space: Think in Transformations 🔄 Solved LeetCode 48 - Rotate Image today. The elegant trick: 1. Transpose the matrix (swap rows ↔ columns) 2. Reverse each row That’s it. No extra matrix needed. Instead of simulating rotation element by element, the problem becomes a composition of two simple transformations. Key takeaway: Hard matrix problems often reduce to recognizing the right geometric transformation. When you see the pattern, the implementation becomes clean and in-place. Another strong boost to 2D intuition. #LeetCode #DSA #Matrix #InPlaceAlgorithm #JavaScript #ProblemSolving #LearnInPublic

🚀 JavaScript Prototypes Explained (Beyond “Classes”) Spent time breaking down how JavaScript actually handles inheritance under the hood. Here’s the mental model that made everything click 👇 🧠 Core Concepts: • Prototype Chain (object → parent → null) • Shared vs Instance Properties • What new actually does internally • Object.create() for manual inheritance • ES6 Classes & Static Methods 💡 Key Insight: class in JavaScript is just syntactic sugar over prototypes. Once you understand prototypes, inheritance is no longer a black box. 💻 Pattern-Based Problem Solving Focused on writing optimal solutions: • Maximum Subarray → Kadane’s Algorithm (O(n)) • Product of Array Except Self → Prefix/Suffix (O(n)) • Majority Element → Boyer–Moore (O(1) space) Instead of solving randomly, approached problems through patterns. 💡 Takeaway: When the pattern is clear, the problem becomes simple. Building a deeper understanding of how JavaScript really works — not just how to use it. 💪 #JavaScript #DSA #WebDevelopment #ProblemSolving #FrontendDeveloper #MERNStack Prototype Chain flow 👇

From Sorted Data to Balanced Trees: Divide, Conquer, Balance 🌳 Solved LeetCode 108 - Convert Sorted Array to Binary Search Tree today. The solution clicked by treating the array like a search space: -Pick the middle element as the root -Recursively build the left half and right half -Stop when the range becomes invalid This guarantees a height-balanced BST without extra work. Key takeaway: Balanced trees are a natural outcome of divide-and-conquer. Choosing the midpoint at every step keeps depth under control. Strengthening recursive thinking and tree intuition. #LeetCode #DSA #BinarySearchTree #Recursion #DivideAndConquer #JavaScript #ProblemSolving #LearnInPublic

Day 10/100 – LeetCode 523: Continuous Subarray Sum Solved using the prefix sum + hashmap (modulo) technique. Key idea: if two prefix sums have the same remainder mod k, the subarray between them is divisible by k. ⏱️ Time Complexity: O(n) 🧠 Space Complexity: O(k) Patterns make hard problems simple 💪 #100DaysOfCode #LeetCode523 #DSA #JavaScript #PrefixSum #ProblemSolving