Balancing Binary Search Tree with Inorder Traversal and Divide & Conquer

Day 103 of #200DaysOfCode Leveling up Today I solved "Find Peak Element" on LeetCode using the Binary Search technique. Key Idea: A peak element is greater than its neighbors, and instead of searching linearly, we can eliminate half the search space at each step. Approach: • Use binary search on the array • If nums[mid] < nums[mid + 1] • Else move left (including mid) • Eventually converge to a peak index Concepts Used: • Arrays • Binary Search • Divide & Conquer Thinking Time Complexity: O(log n) Space Complexity: O(1) Takeaway: Binary search is not just for sorted arrays — it’s a powerful pattern to optimize search in “decision-based” problems. New challenge, same mindset Let’s keep pushing consistency to the next level #Day103 #200DaysOfCode #LeetCode #BinarySearch #Arrays #Cpp #CodingJourney #ProblemSolving #KeepGoing

Day 170/365 – DSA Challenge 🚀 Solved Convert Sorted Array to Binary Search Tree on LeetCode today. 🔹 Problem: Given a sorted array, convert it into a height-balanced Binary Search Tree (BST). 🔹 Approach Used: Recursion (Divide & Conquer) Steps followed: 1️⃣ Pick the middle element of the array → root 2️⃣ Recursively build: Left subtree from left half Right subtree from right half 3️⃣ Repeat until subarray becomes empty 🔹 Key Idea: Choosing the middle element ensures balance of the BST. 🔹 Time Complexity: O(n) 🔹 Space Complexity: O(log n) (recursion stack) 💻 Language: C++ A clean and elegant problem that strengthens BST properties + recursion intuition. #Day170 #365DaysOfCode #DSA #LeetCode #BinaryTree #BST #Recursion #CodingChallenge #Cpp

🚀 Day 72/100 – LeetCode Challenge ✅ Problem Solved: Unique Binary Search Trees II 💡 Difficulty: Medium Today’s problem was all about generating all structurally unique BSTs for a given n. 🔍 Key Learnings: Used Recursion + Divide & Conquer Tried each number as a root node Recursively built: Left subtree → smaller values Right subtree → larger values Combined all possible left & right subtrees to form unique BSTs 🧠 Insight: This problem is a classic example of: ➡️ "Generate all possible structures" Which means: Pick a root Solve subproblems Combine results ⚡ Performance: ⏱ Runtime: 1 ms 🚀 Beat: 99.37% submissions

🚀 LeetCode 438 — Find All Anagrams in a String | Solved ✅ Solved a Medium-level problem using Sliding Window + Hashing. 🔍 Approach: Maintained a dynamic window and tracked character frequencies to efficiently detect anagrams without re-sorting. ⚡ Complexity: Time: O(n) Space: O(1) (optimized using fixed-size array) 💡 Key Learning: Optimizing from hashmap → array significantly improves performance in character-based problems. Step by step, getting better at pattern recognition 🧠 #LeetCode #DSA #SlidingWindow #CodingJourney #ProblemSolving

Day 3 of My DSA Journey | LeetCode Continuing my journey with another important problem 🚀 ✅ Problem: Valid Parentheses What I Learned: Use of Stack (LIFO concept) How to handle matching pairs efficiently Importance of order in problem solving. Approach: Traversed the string and used a stack to store opening brackets. Whenever a closing bracket appeared, I checked if it matches the top of the stack and removed it ✨ Key Takeaway: Stack is the best data structure when dealing with matching patterns and order-based problems.

Day 5️⃣ /15 — Consistency Challenge 🚀 Today’s problem: LeetCode 1855 — Maximum Distance Between a Pair of Values Solved using a clean two-pointer approach. 🔹 Problem Idea: We need to find the maximum value of j - i such that: i <= j nums1[i] <= nums2[j] Both arrays are non-increasing (sorted in descending order), which makes this a perfect two-pointer problem. 🔹 Approach (Two Pointers): Start two pointers: i = 0 for nums1 j = 0 for nums2 Traverse while both pointers are in bounds: If nums1[i] <= nums2[j] ✅ Valid pair found Update answer with j - i Move j forward to try for a larger distance Else (nums1[i] > nums2[j]) ❌ Invalid pair Move i forward to reduce nums1[i] and try to make condition valid 🔹 Time Complexity: Each pointer moves at most once through its array 👉 O(n + m) 🔹 Space Complexity: 👉 O(1) Clean logic, efficient solution, and another step in the consistency journey 💯 #LeetCode #DSA #TwoPointers #Consistency #CodingJourney #LearnInPublic

🚀 Day 248 of #500DaysOfCode Solved LeetCode 396 – Rotate Function 🔄 💡 Approach: Instead of recomputing every rotation (which would be O(n²)), we use a mathematical relation Let: sum = total sum of array F(0) = initial rotation value Then: F(k) = F(k-1) + sum - n * nums[n-k] ⚡ Key Insight: Each rotation shifts weights → reuse previous result This reduces redundant computation drastically ⏱️ Complexity: Time: O(n) Space: O(1) ✨ Takeaway: Whenever rotations are involved, look for a pattern / recurrence instead of brute force. Consistency continues 🔥 #LeetCode #DSA #Arrays #Math #Optimization #Consistency

Day 85/150 🚀 LeetCode 173: Binary Search Tree Iterator 🧠 Problem Design an iterator over a BST that returns nodes in in-order traversal (sorted order). 💡 Approach • Use stack to simulate in-order traversal • Push all left nodes initially • On next(), pop node and process right subtree • Maintain smallest element at top of stack ⏱ Time Complexity O(1) amortized per operation 📦 Space Complexity O(h) (stack) ✅ Result: Accepted ⚡ Runtime: 7 ms BST concepts getting stronger 🌳 #Day85 #LeetCode #BinarySearchTree #Stack #Inorder #DSA #CodingJourney #ProblemSolving

Day 88 of #100DaysOfCode Today I solved "Construct Binary Search Tree from Preorder Traversal" on LeetCode using Recursion + Range Validation. Key Idea: In preorder traversal, elements are processed as: Root → Left → Right We can rebuild the BST by maintaining a valid range (lower, upper) for each node. Approach: • Start with range (-∞, +∞) • Pick current value → create node • For left subtree → range becomes (lower, root value) • For right subtree → range becomes (root value, upper) • Move index forward while constructing tree This ensures we build a valid BST without searching Concepts Used: • Binary Search Tree (BST) • Recursion • Preorder Traversal • Range constraints Time Complexity: O(n) Space Complexity: O(h) This problem shows how powerful range-based recursion can be for tree construction Understanding traversal patterns is unlocking new levels #Day88 #100DaysOfCode #LeetCode #BST #Recursion #Cpp #CodingJourney

Day 97/100 – #100DaysOfLeetCode 🚀 🧩 Problem: LeetCode 456 – 132 Pattern(Medium) 🧠 Approach: Traverse the array from right to left while maintaining a stack. Use a variable to track the “middle” element (the ‘2’ in 132 pattern) and check if a valid pattern exists. 💻 Solution: class Solution:   def find132pattern(self, nums: List[int]) -> bool:     stack = []     third = float('-inf')        for i in range(len(nums) - 1, -1, -1):       if nums[i] < third:         return True              while stack and nums[i] > stack[-1]:         third = stack.pop()              stack.append(nums[i])          return False ⏱ Time | Space: O(n) | O(n) 📌 Key Takeaway: Using a monotonic stack while iterating backwards helps efficiently detect complex patterns in linear time. #leetcode #dsa #development #problemSolving #CodingChallenge