Java Binary Tree Patterns LeetCode Solutions

🚀 DSA Daily Challenge – Day 15 🧠 724. Find Pivot Index (Easy) Another clean prefix-sum based problem from LeetCode — simple idea, elegant execution. 🔍 Problem Recap We’re given an integer array nums. 👉 A pivot index is where: Sum of elements on the left = Sum of elements on the right If multiple pivots exist → return the leftmost one If none exist → return -1 💡 First Thought Brute force approach would be: For every index Calculate left sum Calculate right sum Compare But that would cost O(n²) ❌ We can do better. 🧠 Core Insight Instead of recalculating sums repeatedly: 1️⃣ First compute total sum of the array 2️⃣ Keep a running left sum while iterating 3️⃣ Derive right sum using: Right Sum = Total Sum − Left Sum − Current Element This avoids recomputation completely. 🔄 Step-by-Step Logic Start with leftSum = 0 Compute totalSum Iterate through the array: Calculate rightSum If leftSum == rightSum → return index Add current element to leftSum If no pivot found → return -1 🔥 Why This Works At every index: We conceptually split the array into: Left | Pivot | Right Instead of calculating both sides repeatedly, we: Maintain left sum dynamically Derive right sum mathematically Each element is processed once. ⚙️ Complexity ⏱ Time Complexity: O(n) 📦 Space Complexity: O(1) 🧠 Pattern to Remember 👉 Prefix Sum 👉 Running Sum Technique 👉 Convert nested loop problems into single-pass solutions 👉 Mathematical transformation to avoid recomputation 🧩 Dry Run Example Array: [1, 7, 3, 6, 5, 6] Total Sum = 28 At index 3 (value = 6): Left Sum = 11 Right Sum = 28 − 11 − 6 = 11 Balanced ✅ Pivot Index = 3 🆚 Pattern Connection ProblemCore IdeaRemove DuplicatesTwo PointersMerge Sorted ArrayTwo Pointers (from back)Find Pivot IndexPrefix / Running Sum See the growth? We’re now combining pointer thinking with mathematical optimization. 💪 Consistency builds pattern recognition. Pattern recognition builds speed. Speed builds confidence. 🚀 Ready for Day 16? #DSA #LeetCode #PrefixSum #Arrays #CodingInterview #Java #100DaysOfCode #ProblemSolving #DataStructures #InterviewPrep

✂️ DSA Practice — Remove All Occurrences of a Character (Recursive Approach) Today I solved Remove all occurrences of a character in a string using a recursive approach, focusing on careful index handling and in-place modification. 🔍 Key Learnings Recursion is useful even for string manipulation problems. When modifying a string in-place, index management is critical. After deletion, characters shift left — so the index should not advance. Clear base cases prevent infinite recursion. 🧠 Why This Problem Matters Strengthens understanding of recursion with mutable data structures. Helps build intuition for string traversal and modification. Common problem to test attention to detail and edge cases. 📌 Final Takeaway This problem highlights that recursion isn’t just about breaking problems down — it’s also about understanding how data changes during execution. #dsa #recursion #strings #problemSolving #codingpractice #java #datastructures #interviewpreparation #algorithms #100DaysOfCode #softwareengineering

🚀 Today’s DSA Progress Consistency > Motivation 💯 Today I worked on strengthening my Data Structures & Algorithms fundamentals. ✅ Topics Covered: 🔁 Linear Search (1D & 2D arrays) 📊 2D Array traversal using nested loops 💰 Richest Customer Wealth problem 🔍 Searching element index in 2D array 🔄 Valid Palindrome using 2-Pointer approach 💡 Key Learnings: Importance of choosing the right loop (for vs for-each) Understanding row vs column traversal in 2D arrays Why 2-pointer approach is space efficient (O(1)) Debugging common errors like ArrayIndexOutOfBoundsException Small steps every day build strong problem-solving skills. Staying consistent and enjoying the process 🚀 Github: https://lnkd.in/dcs6CWYQ #DSA #Java #CodingJourney #ProblemSolving #100DaysOfCode

🚀 Day 45 Out of #365DaysOfCode - LeetCode Github link: https://lnkd.in/gGUy_MKZ Today I solved an interesting problem: Given a sorted array that has been rotated between 1 and n times, find the minimum element in O(log n) time. 💡 Key Insight: Even though the array is rotated, it still contains two sorted halves. Using Binary Search, we can efficiently locate the pivot point (the smallest element) instead of scanning the whole array. 📌 This problem is a great reminder that understanding patterns in sorted structures can drastically improve performance. Consistency in practicing data structures & algorithms really sharpens problem-solving skills. #DataStructures #Algorithms #BinarySearch #Java #CodingPractice #InterviewPrep #ProblemSolving

𝐃𝐚𝐲 𝟏𝟓 – 𝐃𝐒𝐀 𝐉𝐨𝐮𝐫𝐧𝐞𝐲 | 𝐀𝐫𝐫𝐚𝐲𝐬 🚀 Today’s problem focused on grouping logic using arrays + hashing concepts 🗂️ and understanding different ways to build unique keys. 𝐏𝐫𝐨𝐛𝐥𝐞𝐦 𝐒𝐨𝐥𝐯𝐞𝐝 • 🔤 Group Anagrams 🔹 𝐆𝐫𝐨𝐮𝐩 𝐀𝐧𝐚𝐠𝐫𝐚𝐦𝐬 𝐀𝐩𝐩𝐫𝐨𝐚𝐜𝐡 𝟏 – 𝐒𝐨𝐫𝐭𝐢𝐧𝐠 𝐁𝐚𝐬𝐞𝐝 • 🔄 Converted each word into a char array • 📊 Sorted the characters • 🔑 Used the sorted string as a key in HashMap • 📦 Grouped words sharing the same sorted key 𝐀𝐩𝐩𝐫𝐨𝐚𝐜𝐡 𝟐 – 𝐅𝐫𝐞𝐪𝐮𝐞𝐧𝐜𝐲 𝐀𝐫𝐫𝐚𝐲 𝐁𝐚𝐬𝐞𝐝 • 🔢 Created a frequency array of size 26 • 🧮 Built a unique key using character counts • ⚡ Used computeIfAbsent for cleaner insertion • 📌 Avoided sorting for better efficiency 𝐊𝐞𝐲 𝐋𝐞𝐚𝐫𝐧𝐢𝐧𝐠𝐬 • 🧠 Anagrams share identical character distributions • 🔑 The way you build the key defines performance • ⚡ Frequency-array approach avoids O(k log k) sorting • 📊 Combining arrays with hashing improves efficiency 🧠 𝐓𝐚𝐤𝐞𝐚𝐰𝐚𝐲 Even in array problems, sometimes the real power lies in how you represent the data 🔑 15 days consistent 🔥 On to Day 16 🚀 #DSA #Arrays #Strings #LeetCode #Java #ProblemSolving #DailyCoding #LearningInPublic #SoftwareDeveloper

𝐃𝐚𝐲 𝟐𝟒 – 𝐃𝐒𝐀 𝐉𝐨𝐮𝐫𝐧𝐞𝐲 | 𝐀𝐫𝐫𝐚𝐲𝐬 🚀 Today’s problem focused on applying binary search in a 2D matrix by treating it like a flattened sorted array. 𝐏𝐫𝐨𝐛𝐥𝐞𝐦 𝐒𝐨𝐥𝐯𝐞𝐝 • Search a 2D Matrix 𝐀𝐩𝐩𝐫𝐨𝐚𝐜𝐡 𝟏 – 𝐓𝐨𝐩-𝐑𝐢𝐠𝐡𝐭 𝐒𝐜𝐚𝐧 • Start from the top-right corner • Move left if the current value is greater • Move down if the current value is smaller • Time Complexity: O(n + m) 𝐀𝐩𝐩𝐫𝐨𝐚𝐜𝐡 𝟐 – 𝐑𝐨𝐰-𝐖𝐢𝐬𝐞 𝐁𝐢𝐧𝐚𝐫𝐲 𝐒𝐞𝐚𝐫𝐜𝐡 • Identify the possible row • Apply binary search inside that row • Time Complexity: O(n log m) 𝐀𝐩𝐩𝐫𝐨𝐚𝐜𝐡 𝟑 – 𝐅𝐥𝐚𝐭𝐭𝐞𝐧𝐞𝐝 𝐁𝐢𝐧𝐚𝐫𝐲 𝐒𝐞𝐚𝐫𝐜𝐡 • Treat matrix as a 1D sorted array • Range: 0 to (n × m − 1) • Convert index → row = mid / m, col = mid % m • Apply standard binary search 𝐊𝐞𝐲 𝐋𝐞𝐚𝐫𝐧𝐢𝐧𝐠𝐬 • A 2D matrix can be treated as 1D with index mapping • Binary search is about reducing the search space logically • Index math simplifies multidimensional problems • Choosing the right abstraction makes problems easier 𝐂𝐨𝐦𝐩𝐥𝐞𝐱𝐢𝐭𝐲 • Time: O(log(n × m)) • Space: O(1) 𝐓𝐚𝐤𝐞𝐚𝐰𝐚𝐲 Sometimes the trick is not searching in 2D — it’s thinking in 1D. 24 days consistent. On to Day 25 🚀 #DSA #Arrays #BinarySearch #LeetCode #Java #ProblemSolving #DailyCoding #LearningInPublic #SoftwareDeveloper

Group Anagrams — 49 🎯 Goal Group strings that are anagrams and return them as a list of groups. Anagram: Strings having the same characters with the same frequency (order does not matter). Core Intuition We need to group items based on a common property. Property here = same character composition Best data structure for grouping by a property → HashMap Approach 1 — Sorting (Brute / Standard) If we sort a string, all anagrams become identical. Example: eat → aet tea → aet ate → aet So we can: - Sort each string - Use the sorted string as the key - Store original strings as values in a HashMap Complexity Let: - N = number of strings - K = average string length Time Complexity: O(N × K log K) (because sorting each string takes K log K) Space Complexity: O(N × K) Worst case: if all strings are different, each gets stored separately in the HashMap. Trade-off Sorting is simple and clean, but: If strings are very large, sorting becomes expensive. Optimized Approach — Frequency Count To avoid sorting cost, we can use character frequency. This works when: - All characters are lowercase (or uppercase) - Fixed alphabet size (26) Idea - Create an array of size 26. - Traverse each string and count character frequency. - Convert this frequency array into a string. - Use that string as the HashMap key. Now: - Building key = O(K) - No sorting needed. Complexity Time Complexity: O(N × K) Space Complexity: O(N × K) Extra space used is constant (26-size array), but we gain better time performance. 🕸Trap Trying to use an array/list directly as a HashMap key. In Java: - Arrays do not implement "equals()" properly for value comparison. ✔ Always convert frequency array to a String before using it as a key. Trigger Whenever you see: Group items based on a property Think: HashMap + Generated Key If I missed anything or if you have a better approach, please feel free to add it in the comments 🙌 #DSA #LeetCode #Java #Algorithms #ProblemSolving #CodingJourney #InterviewPreparation #SoftwareEngineer

People think Senior Engineers have memorized the entire documentation. 📚 I have designed scalable data architectures. I have optimized massive Semantic Models. I have built automated pipelines from scratch. But... honestly, our search history usually looks like this: "python string to date format" 🐍 "pandas drop duplicates syntax" 🐼 "DAX KEEPFILTERS vs FILTER logic" 📊 The Myth: Senior Engineers memorize every function. The Reality: Senior Engineers know what to search for and how to apply the answer efficiently. Don't feel bad if you have to look up the basics. We all do. 🤝 #ImposterSyndrome #PowerBI #DataEngineering #DAX #Python #RealityCheck

🚀 DSA Journey Update: ArrayList Mastered. ✅ I’ve completed ArrayList (Java Collections) — a crucial step in understanding dynamic data handling and efficient data manipulation. This phase strengthened my understanding of how data can be stored, accessed, and optimised in real-world applications. Instead of static arrays, I explored how dynamic structures improve flexibility and performance. ✅ ArrayList Concepts Practised • Dynamic resizing & memory behavior • CRUD operations & traversal techniques • Sorting & searching operations • 2D ArrayLists & matrix-like structures • Efficient element swapping & reverse traversal • Using ArrayLists in algorithmic problems 🧩 Problems & Patterns Explored: • Finding maximum & reverse traversal • Pair Sum (Brute Force vs Two-Pointer Optimisation) • Container With Most Water problem • Sorted & Rotated array pair detection • Multidimensional ArrayList construction Working with ArrayLists helped me understand the transition from basic storage structures to efficient algorithmic solutions. 🔥 What’s Next? → Linked List Data Structure Now moving into Linked Lists, focusing on: • Dynamic node-based memory structure • Insertions & deletions efficiency • Singly & Doubly Linked Lists • Reversal & cycle detection • Real-world use cases & performance tradeoffs Excited to continue building consistency and strengthening problem-solving skills. 📢 What’s Next? Linked List Data Structure. 💬 Which data structure changed the way you think about memory and efficiency? For references, visit my GitHub repository: https://lnkd.in/ge-yVhyS Visit Links: https://lnkd.in/gG-rt7tj https://satinderpoetry.com I’m sharing this to stay consistent and connect with others on the same learning path. #DSA #Java #ArrayList #LinkedList #DataStructures #Algorithms #ProblemSolving #CodingJourney #LearningByDoing #SatinderLearns_DSA

Day 15 of My DSA Journey – Mastering Prefix Sum (Range Sum Query) Today, I worked on a classic and powerful concept in Data Structures: Prefix Sum Array 🔹 Problem: Given an array, answer multiple queries to find the sum between two indices efficiently. 🔹 Key Learning: Instead of recalculating the sum every time (O(n)), we can precompute a prefix array so that each query runs in O(1) time. => Formula: prefix[i] = prefix[i-1] + nums[i] => Range Sum: sumRange(left, right) = prefix[right] - prefix[left-1] (If left == 0, just return prefix[right]) This approach is widely used in: ✔️ Competitive Programming ✔️ Interview Questions ✔️ Real-world data analytics Feeling more confident with optimization techniques today Consistency really pays off! #Day15 #DSA #PrefixSum #LeetCode #CodingJourney #Java #ProblemSolving #LearningInPublic #TechGrowth