Java DSA: Arrays & Two-Pointer Technique for Sorted Array Squares

🚀 Day 40 / 180 – DSA with Java 🚀 📘 Topic Covered: Binary Exponentiation (Fast Power) 🧩 Problem Solved: Pow(x, n) Problem: Implement a function to calculate x raised to the power n, handling both positive and negative values of n. Approach: Used Binary Exponentiation to reduce time complexity. Repeatedly squared the base and halved the exponent, multiplying the result only when needed. Also handled negative powers by taking the reciprocal. Key Learning: ✔️ Optimizing from O(n) to O(log n) ✔️ Understanding divide-and-conquer in exponentiation ✔️ Handling edge cases like negative powers If you’re also preparing for DSA, let’s connect and learn together 🤝 #DSA #Java #180DaysOfCode #LearningInPublic #ProblemSolving #Consistency 

🚀 Day 38 / 180 – DSA with Java 🚀 📘 Topic Covered: Strings & Two-Pointer Technique 🧩 Problem Solved: Is Subsequence Problem: Given two strings s and t, check whether s is a subsequence of t. Approach: Used two pointers to traverse both strings. Moved the pointer in s only when characters matched, and always moved the pointer in t, ensuring order is maintained. Key Learning: ✔️ Applying two-pointer technique on strings ✔️ Understanding subsequence vs substring ✔️ Writing clean and efficient O(n) solutions If you’re also preparing for DSA, let’s connect and learn together 🤝 #DSA #Java #180DaysOfCode #LearningInPublic #Strings #ProblemSolving #Consistency

🚀 Day 36 / 180 – DSA with Java 🚀 📘 Topic Covered: Binary Search (Peak Finding) 🧩 Problem Solved: Find Peak Element Problem: Given an array, find a peak element (an element greater than its neighbors) and return its index. Approach: Used Binary Search by comparing the middle element with its neighbors. Based on the increasing or decreasing slope, moved towards the side where a peak must exist, reducing the search space efficiently. Key Learning: ✔️ Applying binary search on unsorted arrays using patterns ✔️ Understanding how slope direction guides decisions ✔️ Solving peak problems in O(log n) time If you’re also preparing for DSA, let’s connect and learn together 🤝 #DSA #Java #180DaysOfCode #LearningInPublic #BinarySearch #ProblemSolving #Consistency

Mastering Java & DSA Through LeetCode Day 34 Today I solved a Medium-level Tree problem that strengthened my understanding of Prefix Sum + DFS — a powerful pattern used in many interview questions. LeetCode Problem: 437. Path Sum III Problem Summary: Given a binary tree and a target sum, we need to find the number of paths where the sum of node values equals the target. The path must go downward (parent → child), but it doesn’t need to start from the root. Key Insight: Instead of checking all possible paths (which is inefficient), we use: Prefix Sum HashMap to store frequencies DFS traversal This helps reduce time complexity from O(n²) → O(n) ⚡ Approach: Maintain a running sum while traversing the tree Check if (currentSum - target) exists in the map Use backtracking to maintain correct state What I Learned: How prefix sum works in trees (not just arrays!) Optimizing brute-force solutions Importance of hashmap in reducing complexity Consistency Update: Day 34 of solving DSA problems daily 💪 Small steps every day = big results over time #LeetCode #Java #DSA #CodingJourney #100DaysOfCode #SoftwareEngineering #PlacementPreparation #CodingInterview

🚀 Day 45 / 180 – DSA with Java 🚀 📘 Topic Covered: Arrays & Two-Pointer Technique 🧩 Problem Solved: Merge Sorted Array Problem: Given two sorted arrays, merge the second array into the first one as a single sorted array. Approach: Started comparing elements from the end of both arrays and filled the first array from the last position backwards. This avoided shifting elements and enabled an efficient in-place merge. Key Learning: ✔️ Using reverse traversal for in-place operations ✔️ Applying two-pointer technique effectively ✔️ Merging sorted data in O(m + n) time If you’re also preparing for DSA, let’s connect and learn together 🤝 #DSA #Java #180DaysOfCode #LearningInPublic #Arrays #ProblemSolving #Consistency

🚀 Day 42 / 180 – DSA with Java 🚀 📘 Topic Covered: Linked List Traversal 🧩 Problem Solved: Find Middle of Linked List Problem: Given the head of a linked list, find and return the middle node’s value. Approach: First traversed the linked list to calculate its length. Then traversed again up to the middle index to retrieve the middle node. Key Learning: ✔️ Understanding linked list traversal ✔️ Breaking problems into multiple passes ✔️ Thinking about optimized approaches (like slow-fast pointers) If you’re also preparing for DSA, let’s connect and learn together 🤝 #DSA #Java #180DaysOfCode #LearningInPublic #LinkedList #ProblemSolving #Consistency

🚀 Day 44 / 180 – DSA with Java 🚀 📘 Topic Covered: Binary Search on Answer 🧩 Problem Solved: Koko Eating Bananas Problem: Given banana piles and limited hours, find the minimum eating speed required to finish all piles within the given time. Approach: Applied Binary Search on the possible eating speed range. For each speed, calculated total hours needed and adjusted the search space until finding the minimum valid speed. Key Learning: ✔️ Understanding binary search beyond arrays ✔️ Applying search on answer space efficiently ✔️ Solving optimization problems in O(n log m) time If you’re also preparing for DSA, let’s connect and learn together 🤝 #DSA #Java #180DaysOfCode #LearningInPublic #BinarySearch #ProblemSolving #Consistency

Day 60 of My Java DSA Journey Today I solved an important Binary Search Tree problem: 💡 Recover Binary Search Tree (RBST) 🧠 Approach: • Performed inorder traversal of BST • Identified violations where the inorder sequence is not sorted • Tracked misplaced nodes using three pointers: first (first violation) middle (adjacent swap case) last (non-adjacent swap case) • Swapped the incorrect node values to restore BST properties 🔍 Key Insight: Inorder traversal of a BST should always be sorted. If two nodes are swapped, we can detect them by finding “inversion points” in the inorder sequence and fix the tree without changing structure. ⚡ What I learned: • Strong understanding of BST inorder properties • How to detect structural violations in trees • Handling adjacent vs non-adjacent swapped nodes • Importance of pointer tracking in recursive traversal 🔥 Complexity: • Time: O(n) • Space: O(h) (recursion stack) 🎯 Takeaway: Tree problems are not just about traversal — they test your ability to observe patterns in structure and fix them with minimal changes. #Day60 #90DaysOfCoding #DSA #BST #Java #ProblemSolving #BinaryTree

🚀 Day 46 / 180 – DSA with Java 🚀 📘 Topic Covered: Matrix Manipulation 🧩 Problem Solved: Rotate Image Problem: Given an n x n matrix representing an image, rotate it 90 degrees clockwise in-place. Approach: First transposed the matrix by swapping rows and columns across the diagonal. Then reversed each row to complete the 90-degree clockwise rotation efficiently without extra space. Key Learning: ✔️ Breaking matrix problems into smaller transformations ✔️ Understanding transpose operations ✔️ Solving in-place matrix rotation with O(1) extra space If you’re also preparing for DSA, let’s connect and learn together 🤝 #DSA #Java #180DaysOfCode #LearningInPublic #Matrix #ProblemSolving #Consistency 💙

🚀 Java DSA Progress Update I’ve solved 125/310 problems (~40%) as part of my structured Java DSA roadmap. ✔️ Strong in: Arrays, Strings, Linked Lists, Binary Search ⚡ Focusing next on: Heap, Graphs, Dynamic Programming, Sliding Window 📌 Approach: Pattern-based problem solving Time & space analysis Learning from mistakes Re-solving for retention 🎯 Goal: Become interview-ready in 30 days with strong problem-solving fundamentals. Consistent progress > perfection. #Java #DSA #LeetCode #ProblemSolving #SoftwareEngineering