Next Greater Element II: Stack + Circular Array

🔥 Day 224 - Daily DSA Challenge! 🔥 Problem: 🌳 Binary Search Tree Iterator Implement an iterator over a BST that returns elements in ascending order (inorder traversal) — one value at a time. 💡 Key Insights: 🔹 A stack-based approach efficiently simulates inorder traversal without recursion. 🔹 Always push the leftmost nodes of the tree to the stack — these are the next smallest elements. 🔹 When next() is called, pop from the stack and push the left path of the right subtree. 🔹 This ensures the iterator always has the next smallest node ready. ⚡ Optimized Plan: ✅ Use a stack to store nodes while traversing left. ✅ next() → Pop the top, then push all left nodes of its right subtree. ✅ hasNext() → Check if the stack is non-empty. ✅ Time Complexity: next(): O(h) in worst case (h = height of tree), amortized O(1). hasNext(): O(1). ✅ Space Complexity: O(h) — for the stack. 💬 Challenge for you: 1️⃣ Can you create a reverse BST iterator (descending order)? 2️⃣ How would you adapt this to work with preorder or postorder traversal? #DSA #BinarySearchTree #Iterator #Stack #LeetCode #ProblemSolving #CodingChallenge #KeepCoding #100DaysOfCode

🔥 Day 222 - Daily DSA Challenge! 🔥 Problem: 🌳 Flatten Binary Tree to Linked List Given the root of a binary tree, flatten it into a linked list in-place, following the preorder traversal order (root → left → right). 💡 Key Insights: 🔹 The goal is to modify the tree without using extra space. 🔹 For each node, if a left subtree exists: 1️⃣ Find the rightmost node of the left subtree. 2️⃣ Connect that node’s right pointer to the current node’s right subtree. 3️⃣ Move the left subtree to the right and set left = null. 🔹 Repeat this process while traversing through the tree. ⚡ Optimized Plan: ✅ Traverse using a pointer (curr). ✅ If curr.left exists, attach it in place of curr.right and re-link the subtrees. ✅ Continue the process until the end of the tree. ✅ Time Complexity: O(n) — each node visited once. ✅ Space Complexity: O(1) — in-place transformation. 💬 Challenge for you: 1️⃣ Can you flatten the tree using recursion instead of iteration? 2️⃣ How would you modify this to produce a postorder or inorder flattened list? #DSA #BinaryTree #LinkedList #LeetCode #ProblemSolving #CodingChallenge #KeepCoding #100DaysOfCode

🔗 Day 75 of #100DaysOfCode 🔗 🌳 Problem: Binary Tree Postorder Traversal – LeetCode ✨ Approach: Implemented a recursive depth-first traversal that processes the left subtree, then right subtree, and finally the root node — perfectly matching the postorder pattern (Left → Right → Root). The solution is clean, intuitive, and highlights the elegance of recursion in tree traversal! 🌿 📊 Complexity Analysis: ⏱ Time Complexity: O(n) — each node is visited exactly once 💾 Space Complexity: O(n) — recursion stack in the worst case (skewed tree) ✅ Runtime: 0 ms (Beats 100% 🚀) ✅ Memory: 43.07 MB 💡 Key Insight: Recursion beautifully mirrors the natural hierarchy of trees — by trusting the call stack, we achieve simplicity and clarity in solving even complex traversal problems. 🌱 #LeetCode #100DaysOfCode #ProblemSolving #DSA #BinaryTree #Recursion #AlgorithmDesign #CodeJourney #ProgrammingChallenge #LogicBuilding #Efficiency #CodingDaily

🌟 Day 84 of #100DaysOfCode 🌟 🔹 Problem Solved: Check If All 1's Are at Least K Places Away – LeetCode Today’s challenge was all about precision, pattern detection, and distance validation within a binary array. The goal? Ensure every 1 is properly spaced and respects the minimum distance k. ✨ Approach: I iterated through the array, tracked the position of each 1, and checked the gap before encountering the next one. A simple but effective two-pointer style logic! 📊 Complexity Analysis: ⏱ Time Complexity: O(n) — single pass through the array 💾 Space Complexity: O(1) — constant extra memory 🚀 Performance: ✔ Runtime: 1 ms (Beats 99.71%) ✔ Memory: 65.68 MB 🔑 Key Insight: Even a straightforward problem can sharpen your ability to detect patterns and handle constraints efficiently. Small details—like distances between bits—can make or break logic. #LeetCode #DSA #CodingChallenge #100DaysOfCode #ProblemSolving #BinaryArray #Algorithms #TechJourney #CodeEveryday #JavaCoding

🔍 Day 66 of #100DaysOfCode 🔍 🔹 Problem: Binary Search – LeetCode ✨ Approach: Implemented an iterative binary search to efficiently locate the target element within a sorted array. By halving the search range each time — adjusting low and high around the mid-point — the algorithm achieves blazing-fast lookups! ⚡ 📊 Complexity Analysis: Time Complexity: O(log n) — array size halves with each iteration Space Complexity: O(1) — constant extra space ✅ Runtime: 0 ms (Beats 100.00%) ✅ Memory: 46.02 MB 🔑 Key Insight: Binary Search is proof that efficiency isn’t about doing more — it’s about eliminating what’s unnecessary. 🚀 #LeetCode #100DaysOfCode #ProblemSolving #DSA #AlgorithmDesign #BinarySearch #LogicBuilding #Efficiency #ProgrammingChallenge #CodeJourney #CodingDaily

🔹 Problem: Binary Tree Inorder Traversal Day 122 🔹 Difficulty: Easy 🔹 Topic: Binary Tree / Morris Traversal / Iterative Traversal 🔍 Problem Breakdown: We are given the root of a binary tree, and we need to return the inorder traversal of its nodes’ values. 📘 Inorder Traversal: Left → Root → Right Usually, this can be solved using recursion or stack, but today’s approach uses Morris Traversal, which is O(1) extra space and does not use recursion or stack. 🧠 Approach (Morris Traversal): Start with the current node = root. If the left child is NULL, visit the node and move right. Else, find the inorder predecessor (rightmost node in the left subtree). If predecessor’s right is NULL, make a temporary link to the current node and move left. If predecessor’s right is current, remove the link, visit current node, and move right. Continue until all nodes are visited. This method avoids recursion and stack by establishing temporary links in the tree. ⏱️ Time & Space Complexity: Time Complexity: O(n) — each edge is visited twice. Space Complexity: O(1) — no recursion or stack used. 💡 Key Insight: Morris Traversal is a brilliant way to traverse binary trees in constant space, by cleverly using tree links as temporary pointers — elegant and efficient! #LeetCode #DSA #BinaryTree #MorrisTraversal #InorderTraversal #ProblemSolving #CodingChallenge #200DaysOfCode #Cplusplus

🚀LeetCode Daily Challenge 🧩 Problem: Find X-Sum of All K-Long Subarrays I Problem Intuition: You are given an integer array nums and two integers k and x. For every subarray of length k, you must find the X-sum, which is the sum of the top x most frequent elements in that subarray with each element contributing (frequency × element) to the sum. If there are fewer than x distinct elements, you take all available ones. 💡Example Insight: Let nums = [1,1,2,2,3], k = 3, x = 2. Subarrays of length 3 are: [1,1,2], [1,2,2], [2,2,3] For [1,1,2]: Frequencies → {1: 2, 2: 1} Top 2 → (1×2) + (2×1) = 4 So the result for each subarray gives the X-sum pattern accordingly. 🧠 Approach & Strategy: ✔ Use a sliding window of size k to process subarrays efficiently. ✔ Maintain a frequency map (unordered_map<int, int>) for elements inside the current window. ✔ For each valid window: 🔹 Build a max-heap (priority queue) based on element frequencies. 🔹 Pop the top x elements (highest frequencies) and calculate their contribution to the X-sum. ✔ Store the sum in the result vector and slide the window forward. ⚙️ Complexity Analysis: Time Complexity: O(n × log m) → where m is the number of distinct elements in each window. Space Complexity: O(m) → for maintaining the frequency map and heap. 🔗 Problem: https://lnkd.in/dtWEDDrj 💻 Solution: https://lnkd.in/du3Mmi4S #LeetCode #DSA #Cpp #ProblemSolving #CodingChallenge #LeetCodeDailyChallenge

🚀 𝐋𝐞𝐞𝐭𝐂𝐨𝐝𝐞 𝐃𝐚𝐢𝐥𝐲 𝐂𝐡𝐚𝐥𝐥𝐞𝐧𝐠𝐞: 𝟑𝟐𝟐𝟖-𝐌𝐚𝐱𝐢𝐦𝐮𝐦 𝐍𝐮𝐦𝐛𝐞𝐫 𝐨𝐟 𝐎𝐩𝐞𝐫𝐚𝐭𝐢𝐨𝐧𝐬 𝐭𝐨 𝐌𝐨𝐯𝐞 𝐎𝐧𝐞𝐬 𝐭𝐨 𝐭𝐡𝐞 𝐄𝐧𝐝 🧩 Problem Statement: You’re given a binary string s. You can repeatedly choose an index i where s[i] == '1' and s[i + 1] == '0', and move that '1' to the right until it reaches the end or another '1'. You need to return the maximum number of operations that can be performed. Example: Input: s = "1001101" Output: 4 🧠 Approach: The idea is to notice that every '1' before a block of '0' can move once for that block. So, as we traverse the string :- • Keep counting '1's as they appear. • When we encounter a block of '0's, add the total number of '1's seen so far to our answer. • This way, each zero block contributes operations equal to the number of ones before it. Time Complexity: O(n) Space Complexity: O(1) #LeetCode #ProblemSolving #DSA #CodingJourney #LogicBuilding #DailyChallenge #KeepLearning #100DaysOfCode

✨ Day 50 of 50 Days Challenge ✨ Solved LeetCode 154: Find Minimum in Rotated Sorted Array II (Hard) 👉 Problem Statement: Given a sorted array that has been rotated between 1 and n times and may contain duplicate elements, find the minimum element in the array. The goal is to minimize operations (preferably better than O(n)). 📌 Examples: Input: nums = [1,3,5] Output: 1 Input: nums = [2,2,2,0,1] Output: 0 🔎 Approach Used: ➡️ Modified Binary Search (Handles Duplicates) 1. Initialize two pointers — start and end. 2. If elements at start, mid, and end are equal, shrink the range (start++, end--). 3. If the left half is sorted, update minEle with nums[start] and move to the right. 4. Otherwise, update minEle with nums[mid] and move to the left. 5. Continue until the minimum element is found. ✅ Complexity Analysis: Time Complexity: O(log n) on average, can degrade to O(n) (due to duplicates). Space Complexity: O(1) → Constant extra space. #50DaysChallenge #LeetCode #C++ #BinarySearch #RotatedArray #Duplicates #DSA #CodingChallenge #Algorithms

🔹 Day 69 of #100DaysOfLeetCodeChallenge 🔹 🚀 Problem: Subsets II 🔑 Topic: Backtracking 🧠 Approach: The task is to find all unique subsets of an array that may contain duplicates. Here’s the step-by-step logic 👇 Sort the array first to bring duplicates together. Use backtracking to explore every possible subset. Skip duplicates by checking if the current element equals the previous one at the same recursion depth. Add every subset (including empty) to the result list. ⏳ Time Complexity: O(2^n) 💾 Space Complexity: O(n) (recursion stack + temp list) 📌 Example: Input: nums = [1,2,2] Output: [[], [1], [1,2], [1,2,2], [2], [2,2]] ✅ 🎯 Takeaway: Sorting and skipping duplicates isn’t just for combinations — it’s the secret weapon for clean subset generation too! ⚡ #LeetCode #DSA #Backtracking #Subsets #ProblemSolving #CodingChallenge #100DaysOfLeetCodeChallenge 🚀