Convert Sorted Array to Balanced Binary Search Tree

Day 79/100 | #100DaysOfDSA 🧩🚀 Today’s problem: Flatten Binary Tree to Linked List A powerful tree transformation problem using pointer manipulation. Problem idea: Convert a binary tree into a linked list in-place following preorder traversal. Key idea: Iterative traversal + rewiring (similar to Morris traversal idea). Why? • We need preorder sequence (Root → Left → Right) • Instead of extra space, we modify pointers in-place • Efficient and avoids recursion stack How it works: • Traverse using a pointer curr • If left child exists: → Find rightmost node of left subtree → Connect it to current’s right subtree → Move left subtree to right → Set left = null • Move to next node (curr.right) Time Complexity: O(n) Space Complexity: O(1) Big takeaway: Tree problems can often be optimized using in-place pointer rewiring, avoiding extra space. 🔥 This pattern is very useful for tree flattening and traversal optimizations. Day 79 done. 🚀 #100DaysOfCode #LeetCode #DSA #Algorithms #BinaryTree #MorrisTraversal #Java #CodingJourney #ProblemSolving #InterviewPrep #TechCommunity

Day 85/100 | #100DaysOfDSA 🧩🚀 Today’s problem: Populating Next Right Pointers in Each Node A clean pointer-manipulation problem that strengthens tree traversal intuition without extra space. Problem idea: Given a perfect binary tree, connect each node to its next right node using a next pointer. Key idea: Level-by-level traversal using already established next pointers (no queue needed). Why? • The tree is perfect → every level is fully filled • We can use existing next links to move horizontally • This avoids extra space (unlike BFS with a queue) How it works: • Start from the leftmost node of each level • Connect left child → right child • If a next node exists, connect right child → next node’s left child • Move across the level using next pointers • Then go down to the next level Time Complexity: O(n) Space Complexity: O(1) Big takeaway: When a tree is perfect, you can often avoid extra space by cleverly using existing structure (like next pointers). 🔥 This is a powerful pattern for constant-space tree traversal problems. Day 85 done. 🚀 #100DaysOfCode #LeetCode #DSA #Algorithms #BinaryTree #Pointers #TreeTraversal #Java #CodingJourney #ProblemSolving #InterviewPrep #TechCommunity

Day 76/100 | #100DaysOfDSA 🧩🚀 Today’s problem: Lowest Common Ancestor of a Binary Tree A fundamental tree problem that builds strong recursion intuition. Problem idea: Find the lowest node in the tree that has both given nodes as descendants. Key idea: DFS + recursion (bottom-up approach). Why? • Each subtree can independently tell if it contains p or q • Combine results while backtracking • First node where both sides return non-null → answer How it works: • If current node is null / p / q → return it • Recursively search left and right subtree • If both left & right are non-null → current node is LCA • Else return the non-null side Time Complexity: O(n) Space Complexity: O(h) (recursion stack) Big takeaway: Tree problems often rely on post-order traversal + combining child results. Understanding this pattern unlocks many binary tree problems. 🔥 Day 76 done. 🚀 #100DaysOfCode #LeetCode #DSA #Algorithms #BinaryTree #Recursion #DFS #Java #CodingJourney #ProblemSolving #InterviewPrep #TechCommunity

🧠 Day 212 — Maximum Distance Between Valid Pairs 📏⚡ Today solved a solid two-pointer optimization problem on sorted arrays. 📌 Problem Goal Given two non-increasing arrays: ✔️ Find indices (i, j) such that ✔️ i ≤ j and nums1[i] ≤ nums2[j] ✔️ Maximize the distance (j - i) 🔹 Core Idea Use two pointers to efficiently explore valid pairs: ✔️ Start both pointers at the beginning ✔️ Expand j to find valid matches ✔️ Move i only when condition breaks 🔹 Key Observation ✔️ Arrays are sorted in non-increasing order → huge advantage ✔️ If nums1[i] > nums2[j], move i forward ✔️ Otherwise, update answer and try expanding j 🧠 Key Learning ✔️ Two-pointer technique works best on sorted data ✔️ Avoid brute force → think in terms of pointer movement ✔️ Maintain valid window while maximizing distance 💡 Big Realization Whenever you see: 👉 “Maximize/minimize distance” 👉 “Sorted arrays” Think: ➡️ Can I solve this using two pointers instead of nested loops? 🚀 Momentum Status: Strong grip on array + pointer patterns. On to Day 213. #DSA #TwoPointers #Arrays #Optimization #LeetCode #Java #CodingJourney #ConsistencyWins

🚀 Day 8/100 — #100DaysOfLeetCode Another day, another concept unlocked 💻🔥 ✅ Problem Solved: 🔹 LeetCode 73 — Set Matrix Zeroes 💡 Problem Idea: If any element in a matrix is 0, its entire row and column must be converted to 0 — and the challenge is to do this in-place without using extra space. 🧠 Algorithm & Tricks Learned: Instead of using extra arrays, we can use the first row and first column as markers. First pass → mark rows and columns that should become zero. Second pass → update the matrix based on those markers. Carefully handle the first row and first column separately to avoid losing information. ⚡ Key Insight: The matrix itself can act as storage, reducing extra memory usage. 📊 Complexity Analysis: Time Complexity: O(m × n) → traverse matrix twice Space Complexity: O(1) → solved in-place without extra data structures This problem taught me how small optimizations can significantly improve space efficiency. Learning to think beyond brute force every day 🚀 #100DaysOfLeetCode #LeetCode #DSA #MatrixProblems #Algorithms #Java #ProblemSolving #CodingJourney #LearningInPublic

Day 67/100 | #100DaysOfDSA 🧩🚀 Today’s problem: Subsets II Another classic backtracking problem with a twist (duplicates). Problem idea: Generate all possible subsets (power set), but avoid duplicate subsets. Key idea: Backtracking + sorting to handle duplicates. Why? • We need to explore all subset combinations • Duplicates in input can lead to duplicate subsets • Sorting helps us skip repeated elements efficiently How it works: • Sort the array first • At each step, add current subset to result • Iterate through elements • Skip duplicates using condition: 👉 if (i > start && nums[i] == nums[i-1]) continue • Choose → recurse → backtrack Time Complexity: O(2^n) Space Complexity: O(n) recursion depth Big takeaway: Handling duplicates in backtracking requires careful skipping logic, not extra data structures. This pattern appears in many problems (subsets, permutations, combinations). 🔥 Day 67 done. 🚀 #100DaysOfCode #LeetCode #DSA #Algorithms #Backtracking #Recursion #Java #CodingJourney #ProblemSolving #InterviewPrep #TechCommunity

#100DaysOfCode | Day 2 of my LeetCode challenge. Today’s problem: 1365. How Many Numbers Are Smaller Than the Current Number. While the problem seems simple, it’s a perfect example of how choosing the right data structure can drastically change performance. Here is how I broke it down: 1. The Brute Force Approach The most simple and easy way is to use nested loops to compare every number with every other number. Logic: For each element, loop through the entire array and count smaller values. Time Complexity: O(N^2) Space Complexity: O(N) (to store the result) 2. The Sorting + HashMap Approach A more scalable way is to sort the numbers. In a sorted array, a number's index is equal to the count of numbers smaller than it. Logic: Clone the array, sort it, and store the first occurrence of each number in a HashMap. Time Complexity: O(N log N) (due to sorting) Space Complexity: O(N) (to store the map) Use - Works for any range of numbers (including very large or negative ones). 3. The Frequency Array (Counting Sort Logic) Since the problem constraints were small (0 to 100), this is the most optimized solution. Logic: Count the frequency of each number using an array of size 101, then calculate a running prefix sum. Time Complexity: O(N) (Linear time) Space Complexity: O(1) (The frequency array size is constant) #LeetCode #100DaysOfCode #Java #SoftwareEngineering #DataStructures #Algorithms 

Day 115 - LeetCode Journey Solved LeetCode 236 – Lowest Common Ancestor of a Binary Tree ✅ This problem revolves around identifying the lowest common ancestor (LCA) of two given nodes in a binary tree. The LCA is defined as the lowest node in the tree that has both nodes as descendants (a node can be a descendant of itself). Approach: I used a recursive depth-first search (DFS) approach to efficiently locate the LCA. The idea is simple but powerful: • If the current node is null, return null • If the current node matches either of the target nodes (p or q), return the node • Recursively search in the left and right subtrees After recursion: • If both left and right calls return non-null values, the current node is the LCA • If only one side returns non-null, propagate that result upward This works because the first node where both targets split into different subtrees becomes the lowest common ancestor. Complexity Analysis: • Time Complexity: O(n), as we traverse each node once • Space Complexity: O(h), where h is the height of the tree (recursion stack) Key Takeaways: • Tree problems often rely on recursive decomposition 🌳 • Returning meaningful values from recursion simplifies logic • LCA is a classic concept frequently asked in interviews All test cases passed successfully 🎯 #LeetCode #DSA #BinaryTree #Recursion #Java #CodingJourney #InterviewPrep

🚀 Day 574 of #750DaysOfCode 🚀 🔍 Problem Solved: Detect Cycles in 2D Grid Today’s problem was a great example of how graph concepts show up in grids 👀 💡 Key Insight: A grid can be treated as a graph where: Each cell = node Adjacent same-value cells = edges 👉 The task is to detect a cycle of same characters with length ≥ 4 🧠 Approach (DFS + Parent Tracking): Traverse each cell Start DFS if not visited While exploring: Move only to same character cells Track previous (parent) cell If we visit an already visited cell (not parent) → ✅ cycle found 📈 Complexity: Time: O(m × n) Space: O(m × n) ✨ Takeaway: 👉 Many grid problems are just graph problems in disguise 👉 Cycle detection becomes easy with DFS + parent tracking Another solid concept added to the toolkit 💪 #LeetCode #DSA #Java #CodingJourney #ProblemSolving #Graphs #DFS #Algorithms #LearningEveryday

🚀 Solved: Vertical Order Traversal of a Binary Tree (Hard) Just wrapped up solving one of the trickier tree problems — and it was a great reminder that details matter in Data Structures & Algorithms. 🔍 Key Challenge: Not just grouping nodes by vertical columns, but also: Maintaining row-wise ordering Handling same row & same column cases Ensuring sorted output using a min-heap (PriorityQueue) 💡 Core Insight: Instead of a simple BFS, the correct approach required: 👉 Column → Row → MinHeap mapping This ensures: Columns are processed left → right Rows are processed top → bottom Values are sorted when positions overlap ⚙️ Tech Used: BFS traversal TreeMap (for sorted columns & rows) PriorityQueue (for value ordering) 📊 Result: ✔️ All test cases passed ⚡ Runtime: 4 ms 📉 Memory optimized 🧠 Big Learning: Sometimes a problem looks like a simple traversal… …but hidden constraints turn it into a multi-level sorting problem. #DSA #Java #LeetCode #BinaryTree #CodingInterview #ProblemSolving #SoftwareEngineering #LearningJourney