Balancing Binary Search Trees with Inorder Traversal

📌 #61 DailyLeetCodeDose Today's problem: 146. LRU Cache – 🟡 Medium This task looks simple until you remember the O(1) requirement. A map alone is not enough – we also need to track recency. The key idea is combining a hash map with a doubly linked list: the map gives instant access, the list keeps items ordered by usage. Every get or put moves the node to the front, making it the most recently used. When capacity is exceeded, the last node is removed – that's the true LRU. Clean design, strict O(1), and a great reminder that the right data structure is often the whole solution. https://lnkd.in/epVtDYKH #DailyLeetCodeDose #LeetCode #JavaScript #Algorithms #ProblemSolving #Coding

Solved another classic Linked List problem today: Swap Nodes in Pairs on LeetCode. Approach: Used a recursive strategy to swap nodes in pairs. Base condition: if the list has 0 or 1 node, return it as is. For each pair: Store the second node. Recursively process the remaining list. Reverse the current pair by updating pointers. Key pointer operations: temp = head.next head.next = swapPairs(head.next.next) temp.next = head Result: Runtime: 0 ms (Beats 100%) Memory: 52.66 MB (Beats 97.59%) Problems like this reinforce how powerful recursion and pointer manipulation are when working with linked lists. #DSA #LinkedList #LeetCode #JavaScript #ProblemSolving #DataStructures #Algorithms #CodingPractice #SoftwareEngineering #BackendDevelopment

Check if a Binary String Contains Only One Segment of 1s Problem: Given a binary string s, determine whether the string contains only one contiguous segment of '1's. If we ever find a '1' that appears after a '0', it means a new segment of 1s has started — which violates the condition. Approach: -Iterate through the string. -Check if the previous character is '0' and the current character is '1'. -If that happens, it means there are multiple segments of 1s, so return false. 🔍 Time Complexity:O(n) 🔍 Space Complexity:O(1) #javascript #typescript #algorithms #datastructures #leetcode #codingpractice #frontenddeveloper #softwareengineering #problemSolving #100DaysOfCode

𝗪𝗲𝗹𝗰𝗼𝗺𝗲 𝘁𝗼 𝗗𝗮𝘆 𝟮𝟬 What if you could control every interaction with an object — reads, writes, deletes — without changing the object itself? That’s what Proxy does. 𝘼 𝙋𝙧𝙤𝙭𝙮 𝙞𝙨 𝙖 𝙬𝙧𝙖𝙥𝙥𝙚𝙧 𝙖𝙧𝙤𝙪𝙣𝙙 𝙖𝙣 𝙤𝙗𝙟𝙚𝙘𝙩 𝙩𝙝𝙖𝙩 𝙞𝙣𝙩𝙚𝙧𝙘𝙚𝙥𝙩𝙨 𝙡𝙤𝙬-𝙡𝙚𝙫𝙚𝙡 𝙤𝙥𝙚𝙧𝙖𝙩𝙞𝙤𝙣𝙨 𝙡𝙞𝙠𝙚: -> Property access -> Property assignment -> Property deletion -> Function calls -> Object construction 𝙄𝙣𝙨𝙩𝙚𝙖𝙙 𝙤𝙛: Engine → Object 𝙄𝙩 𝙗𝙚𝙘𝙤𝙢𝙚𝙨: Engine → Proxy → Object The Proxy decides what happens. 𝙒𝙝𝙮 𝙄𝙩 𝙈𝙖𝙩𝙩𝙚𝙧𝙨: 𝙋𝙧𝙤𝙭𝙮 𝙡𝙚𝙩𝙨 𝙮𝙤𝙪 𝙘𝙤𝙣𝙩𝙧𝙤𝙡 𝙗𝙚𝙝𝙖𝙫𝙞𝙤𝙧, 𝙣𝙤𝙩 𝙟𝙪𝙨𝙩 𝙙𝙖𝙩𝙖. You can: -> Validate values before saving -> Block unknown properties -> Log every change -> Create computed/virtual properties 𝘛𝘩𝘦 𝘰𝘣𝘫𝘦𝘤𝘵 𝘴𝘵𝘢𝘺𝘴 𝘵𝘩𝘦 𝘴𝘢𝘮𝘦. 𝘛𝘩𝘦 𝘪𝘯𝘵𝘦𝘳𝘢𝘤𝘵𝘪𝘰𝘯 𝘳𝘶𝘭𝘦𝘴 𝘤𝘩𝘢𝘯𝘨𝘦. #JavaScript #JSInternals #FrontendEngineering #WebDevelopment #SoftwareEngineering #ECMAScript #MetaProgramming #FrontendArchitecture #TechDeepDive #Coding

🚀 Cracked a tricky DSA concept today — Search in Rotated Sorted Array (with duplicates) At first glance the array looks unsorted… But actually it’s two sorted arrays joined together 🔍 Example: [2,5,6,0,0,1,2] The challenge ❓ Find a target efficiently (not O(n)) → Use Modified Binary Search (O(log n)) 💡 Key Learning: 1️⃣ One half of the array is always sorted 2️⃣ Check if target lies in the sorted half 3️⃣ If duplicates confuse the search → shrink the window (left++, right--) Core logic: • All equal → ignore edges • Left sorted → search there • Else → search right side 📈 What I learned: Understanding the logic is more important than memorizing code. Today I didn’t just solve a problem — I understood how to think like an algorithm. #DSA #BinarySearch #JavaScript #CodingJourney #100DaysOfCode #ProblemSolving

👉  Binary Tree Maximum Path Sum Using DFS --------------------------------------------------------------------------------------- 43 🔥 The challenge is to find the maximum sum of any path in a binary tree, where a path can start and end at any node (not necessarily passing through the root). ✔ Traverse the tree using Depth First Search (DFS) ✔ Ignore negative paths using Math.max(0, childSum) ✔ Maintain a global maximum path sum ✔ Return only one side (left or right) to the parent to maintain a valid path #DataStructures #Algorithms #BinaryTree #JavaScript #TypeScript #DSA #CodingPractice #ProblemSolving #SoftwareEngineering #FrontendDeveloper #LearningInPublic #100DaysOfCode

🚀 𝗡𝗲𝘄 𝗣𝗥 𝗠𝗲𝗿𝗴𝗲𝗱 I recently tackled a common but insightful logical challenge: finding the second largest number in an array. This 🧩 𝗣𝗿𝗼𝗯𝗹𝗲𝗺 often appears in technical interviews and requires careful thought to handle edge cases effectively. My ⚙️ 𝗔𝗽𝗽𝗿𝗼𝗮𝗰𝗵 involved iterating through the array using JavaScript, keeping track of both the largest and second largest numbers encountered so far. I initialized variables for both to handle the initial comparisons and ensured proper updates as I scanned the array. The 🐞 𝗗𝗲𝗯𝘂𝗴𝗴𝗶𝗻𝗴 𝗣𝗿𝗼𝗰𝗲𝘀𝘀 was crucial. I performed several dry runs mentally to trace the logic, visualized the flow of variables, and used console logs to verify the state of 'largest' and 'secondLargest' at each step. This helped me catch and correct a minor flaw in the initial comparison logic. A 📚 𝗞𝗲𝘆 𝗟𝗲𝗮𝗿𝗻𝗶𝗻𝗴 for me was the importance of precise variable initialization and comparison order to correctly handle duplicate maximum values and empty or single-element arrays. Check out the solution in my latest pull request here: https://lnkd.in/dCcT48U9 How do you ⚙️ 𝗔𝗽𝗽𝗿𝗼𝗮𝗰𝗵 finding the nth largest element in an array? Share your favorite techniques below! 📦 Repo: https://lnkd.in/dCcT48U9 #ArrayManipulation #JavaScript #Algorithm #ProblemSolving #CodingChallenge #Debugging #SoftwareEngineering #LogicalThinking #DataStructures #LearnToCode

✅ Solved LeetCode: Same Tree (100) — Recursive DFS Approach Implemented a clean recursive solution in JavaScript using a structural comparison strategy. Approach: - If both nodes p and q are null, return true. - If only one of them is null, return false. - Otherwise: - Check if p.val === q.val. - Recursively compare: - p.left with q.left - p.right with q.right - Return the combined result of value equality and both subtree comparisons. This approach ensures both structure and node values are identical at every level of the tree. Time Complexity: O(n) — each node is visited once Space Complexity: O(h) — recursion stack space (where h is tree height) A straightforward and elegant recursive pattern for tree comparison problems!

Day 21: The Final Logic – Closures & The Magic of Property Access 🔒✨ Today marks the grand finale of the JavaScript deep-dive. We didn't just look at the code; we looked at the Memory and the Engine logic that governs how variables live and die. 🧠 The "Crack-It Kit" Checklist: Day 21 📑 🔹 The "Stack Overflow" Trap: Understanding why a setter that calls itself triggers a recursion loop, and the "Underscore Logic" (_variable) used to fix it. 🛡️ 🔹 Getters & Setters: Moving beyond simple data storage to "Smart Properties." Whether using Class syntax or Object.defineProperty, it's about intercepting and validating every piece of data. ⚙️ 🔹 The .length Mystery: Breaking down how arr.length actually works. It’s not just a counter—it’s an exotic property managed by the engine with a setter that can physically truncate memory. 🧪 🔹 Lexical Scoping: Mastering the "Hierarchy of Access." Understanding that where you write your code determines what your functions can see. 🏛️ 🔹 Closures (The Memory Lock): The ultimate interview topic. Learning how JS "locks" parent variables in memory to keep them alive for inner functions, even after the parent has finished executing. 🔒 The JavaScript foundation is now 100% complete. From the TCP 3-way handshake to the internal mechanics of Closures, the logic is locked in. 🏗️ #JavaScript #WebDevelopment #CrackItKit #Closures #WebEngineering #CodingJourney #SoftwareArchitecture #TechInterviews #MERNStack #WanderlustProject

🚀 LeetCode Problem Solved – Sort Characters by Frequency Today I solved the “Sort Characters By Frequency” problem on LeetCode. 🔎 Problem Statement: Given a string, sort its characters in decreasing order based on their frequency. 🧠 Key Learning: Instead of directly sorting the string (which isn’t possible since strings are immutable in JavaScript), I: ✔ Counted the frequency of each character using an object ✔ Extracted keys using Object.keys() ✔ Sorted them based on frequency (descending order) ✔ Rebuilt the final string using nested loops 💡 Concepts Used: HashMap / Object for frequency counting Custom sorting with comparator function String building using loops Time Complexity optimization thinking ✨ Example: Input: "tree" Output: "eert" This problem strengthened my understanding of: Frequency-based sorting Custom comparator logic Clean DSA implementation in JavaScript Consistency in solving DSA problems daily 🚀 #LeetCode #DSA #JavaScript #ProblemSolving #CodingJourney #FrontendDeveloper #100DaysOfCode