Validating Binary Search Tree with Global Constraints

🚀 Day 69 of #100DaysOfCode Solved 98. Validate Binary Search Tree on LeetCode 🔗 🧠 Key Insight: A valid BST must satisfy: 👉 Left subtree → all values < root 👉 Right subtree → all values > root 👉 This must hold for every node (not just immediate children) ⚙️ Approach (Range Validation - DFS): 1️⃣ Start with full range: 🔹 (-∞, +∞) 2️⃣ For each node: 🔹 Check if min < node.val < max 🔹 If not → ❌ invalid BST 3️⃣ Recurse left: 🔹 Range becomes (min, node.val) 4️⃣ Recurse right: 🔹 Range becomes (node.val, max) 5️⃣ Return true only if both subtrees are valid ⏱️ Time Complexity: O(n) 📦 Space Complexity: O(h) #100DaysOfCode #LeetCode #DSA #BinaryTree #BST #Recursion #DFS #Java #InterviewPrep #CodingJourney

🧠 Day 206 — Minimum Distance to Target 🎯📍 Today solved a simple yet important problem and did some revision alongside. 📌 Problem Goal Given an array, a target value, and a starting index: ✔️ Find the minimum distance between the start index and any index where the target exists 🔹 Core Idea Traverse the array and: ✔️ Check if current element matches the target ✔️ Calculate distance from the start index ✔️ Keep updating the minimum distance 🔹 Key Observation ✔️ Only indices with the target matter ✔️ Distance = absolute difference between indices ✔️ Simple linear scan gives optimal solution 🧠 Key Learning ✔️ Even easy problems strengthen fundamentals ✔️ Brute-force with clarity > overthinking ✔️ Absolute difference patterns are very common in arrays 💡 Today’s Realization Not every day needs to be a hard problem. Consistency with simple + revision days builds stronger intuition. 🚀 Momentum Status: Staying consistent and sharpening basics. On to Day 207. #DSA #Arrays #ProblemSolving #LeetCode #Java #CodingJourney #ConsistencyWins

Day 84/100 | #100DaysOfDSA 🧩🚀 Today’s problem: Recover Binary Search Tree A very interesting problem that tests your understanding of BST inorder properties. Problem idea: Two nodes in a BST are swapped by mistake. Recover the tree without changing its structure. Key idea: Inorder traversal of a BST should be sorted Why? • BST inorder traversal gives increasing order • If two nodes are swapped → order gets violated • Detect these violations to identify the wrong nodes How it works: • Perform inorder traversal • Track previous node (prev) • If prev.val > curr.val → violation found • First violation → mark first = prev • Second violation → mark second = curr • After traversal → swap values of first and second Optimization (used in your code): Use Morris Traversal to achieve O(1) space (no recursion/stack) Time Complexity: O(n) Space Complexity: O(1) (Morris Traversal) Big takeaway: Whenever working with BST, inorder traversal is your strongest tool. 🔥 Also, detecting anomalies in sorted order is a powerful technique. Day 84 done. 🚀 #100DaysOfCode #LeetCode #DSA #Algorithms #BinarySearchTree #MorrisTraversal #InorderTraversal #Java #CodingJourney #ProblemSolving #InterviewPrep #TechCommunity

🚀 𝗗𝗮𝘆 - 52/60 Problem: Second Most Repeated String in a Sequence 🔍 Learned: Used a HashMap to count frequencies and identified the second highest frequency by carefully tracking both max and second max values along with their corresponding strings. 😅 Struggles: Initially assumed “second most frequent” meant frequency = 2, which was completely wrong. Also messed up handling updates when max changes—missed tracking the correct string. 🧠 Key Learning: Second maximum is not a fixed number—it depends on the dataset. Whenever tracking max values, always track the associated element too. Order of iteration can break logic if not handled properly. 📦 Concepts Used: #HashMap #Strings #FrequencyCount #LogicBuilding #DSA Most bugs don’t come from syntax—they come from wrong thinking. Fix the logic, and the code follows. 🚀 #Java #CodingJourney #ProblemSolving #DSA

LeetCode — Problem 11 | Day 2 💡 Problem: Container With Most Water Given an array of heights, find two lines that together form a container which holds the maximum water. 🧠 My Approach: - Used two pointers (start & end) - Calculated area using "min(height) * width" - Moved the pointer with smaller height to maximize area - Repeated until pointers meet This problem gave a good understanding of: ✔️ Two Pointer Technique ✔️ Optimizing from brute force to O(n) ✔️ Logical thinking in arrays #LeetCode #DSA #Java #CodingJourney

𝐃𝐚𝐲 𝟖𝟏 – 𝐃𝐒𝐀 𝐉𝐨𝐮𝐫𝐧𝐞𝐲 | 𝐀𝐫𝐫𝐚𝐲𝐬 🚀 Today’s problem focused on finding two unique numbers where all others appear twice. 𝐏𝐫𝐨𝐛𝐥𝐞𝐦 𝐒𝐨𝐥𝐯𝐞𝐝 • Single Number III 🔗 https://lnkd.in/dEQaaF3F 𝐀𝐩𝐩𝐫𝐨𝐚𝐜𝐡 – 𝐁𝐢𝐭 𝐌𝐚𝐧𝐢𝐩𝐮𝐥𝐚𝐭𝐢𝐨𝐧 (𝐎𝐩𝐭𝐢𝐦𝐚𝐥) Steps: • XOR all elements → gives a ⊕ b (two unique numbers) • Find rightmost set bit → differentiates a & b • Divide numbers into 2 groups based on that bit • XOR each group → get the two unique numbers 𝐊𝐞𝐲 𝐋𝐞𝐚𝐫𝐧𝐢𝐧𝐠𝐬 • XOR cancels duplicate elements • Bit tricks help split data into meaningful groups • Problems can often be optimized from O(n²) → O(n) • Understanding bit-level operations is very powerful 𝐂𝐨𝐦𝐩𝐥𝐞𝐱𝐢𝐭𝐲 • Time: O(n) • Space: O(1) 𝐓𝐚𝐤𝐞𝐚𝐰𝐚𝐲 When duplicates cancel out, think in terms of XOR and bit patterns. 81 days consistent 🚀 On to Day 82. #DSA #Arrays #BitManipulation #LeetCode #Java #ProblemSolving #DailyCoding #LearningInPublic #SoftwareDeveloper

💡 LeetCode 191 — Number of 1 Bits (Hamming Weight) Recently solved an interesting bit manipulation problem that highlights the power of low-level optimization 🚀 🔍 Problem Statement: Given an unsigned integer, count the number of set bits (1s) in its binary representation. 🧠 Key Insight: Instead of checking every bit individually, we can use a clever trick: 👉 n & (n - 1) removes the rightmost set bit in each operation. This allows us to count only the set bits, making the solution more efficient. ⚙️ Approach Used (Brian Kernighan’s Algorithm): Initialize a counter Repeatedly apply n = n & (n - 1) Increment count until n becomes 0 📈 Time Complexity: O(k), where k = number of set bits (faster than checking all 32 bits) 📦 Space Complexity: O(1) ✨ Why this problem is important: Strengthens understanding of bit manipulation Frequently asked in interviews Useful in low-level optimization and system design 💬 Takeaway: Sometimes the best solutions come from understanding how data is represented at the binary level. Small tricks can lead to big optimizations! #LeetCode #DSA #CodingInterview #Java #BitManipulation #ProblemSolving #TechJourney

Day 86 – Sorted List to Height-Balanced BST Today’s problem was about converting a sorted linked list into a height-balanced Binary Search Tree (BST). 💡 Key Idea: Use the slow & fast pointer technique to find the middle element of the linked list. The middle element becomes the root Left half → left subtree Right half → right subtree 🔁 Apply this recursively to build a balanced BST. 🧠 What I learned: How to simulate array-like access in a linked list Importance of finding the middle efficiently Recursion for tree construction 💻 Time Complexity: O(n log n) 💾 Space Complexity: O(log n) (recursive stack) #Day86 #DSA #Java #CodingJourney #LeetCode #BinaryTree #LinkedList

🚀 LeetCode Challenge 30/50 💡 Approach: HashSet (Sequence Start Detection) Sorting would give O(n log n) — but the problem demands O(n)! The trick? Use a HashSet and only start counting from the BEGINNING of each sequence! 🔍 Key Insight: → Add all numbers to a HashSet (O(1) lookup) → For each number, check if (num - 1) exists in set → If NOT → it's the start of a new sequence! → Count upward (num+1, num+2...) while consecutive numbers exist → Update maxLength at each sequence end 📈 Complexity: ❌ Sorting approach → O(n log n) Time ✅ HashSet approach → O(n) Time, O(n) Space Each number is visited at most twice across all sequences! 🎉 Day 30/50 — 60% done and still going strong! The best optimizations come from asking: ‘What information can I precompute?’ A HashSet turned O(n log n) into O(n)! 🔥 #LeetCode #DSA #HashSet #Java #ADA #PBL2 #LeetCodeChallenge #Day30of50 #CodingJourney #ComputerEngineering #AlgorithmDesign #LongestConsecutiveSequence

Day 105 - LeetCode Journey Solved LeetCode 933: Number of Recent Calls ✅ Simple problem, but a great use of queue + sliding window concept. Idea: Store timestamps in a queue Remove all calls older than t - 3000 Remaining size = answer Key learnings: • Sliding window using queue • Maintaining only relevant data • Efficient real-time processing • Clean O(n) approach ✅ All test cases passed ⚡ O(1) amortized per operation Sometimes clean logic is all you need 💡 #LeetCode #DSA #Queue #SlidingWindow #Java #CodingJourney #ProblemSolving #InterviewPrep