Java DSA: Dutch National Flag Algorithm for Sorting

📈 DSA Practice — Check if an Array is Sorted (Recursive Approach) Today I solved Check if an array is sorted using a recursive approach, focusing on simplicity and clear base-case handling. 🔍 Key Learnings Recursion works well when a problem reduces by one element at a time. Clearly defined base cases prevent unnecessary checks. Comparing adjacent elements is enough to verify sorted order. Recursive solutions can be both clean and expressive. 🧠 Why This Problem Matters Strengthens understanding of recursion fundamentals. Commonly asked as a warm-up interview problem. Builds confidence in breaking problems into smaller subproblems. 📌 Final Takeaway This problem shows that even simple tasks benefit from structured thinking and clean recursive logic. #dsa #recursion #arrays #problemSolving #codingpractice #java #datastructures #interviewpreparation #algorithms #100DaysOfCode #softwareengineering

🔗 DSA Practice — Generate Parentheses (LeetCode 22) Today I solved Generate Parentheses, a classic backtracking problem that beautifully demonstrates how constraints guide recursion. 🔍 Key Learnings Backtracking helps explore all valid combinations efficiently. Maintaining constraints (open vs close count) avoids invalid states. Pruning early reduces unnecessary recursive calls. Recursive tree visualization makes the logic clearer. 🧠 Why This Problem Matters One of the best problems to understand backtracking patterns. Frequently asked in coding interviews. Builds a strong foundation for combinatorial problem-solving. 📌 Final Takeaway This problem shows how powerful recursion becomes when combined with well-defined constraints. Generate only what’s valid — not everything. #leetcode #dsa #backtracking #recursion #problemSolving #codingpractice #java #interviewpreparation #algorithms #100DaysOfCode #softwareengineering

🚀 Today’s DSA Progress! Spent time practicing arrays and strings in LeetCode/NeetCode. Learned some key patterns that are essential for coding interviews: Longest Common Prefix – vertical scanning to find shared prefix. Group Anagrams – HashMap with sorted string or frequency count. Remove Element – in-place removal using two pointers. Majority Element – Boyer-Moore Voting Algorithm (O(n), O(1) space). Sort an Array – Merge Sort for divide-and-conquer sorting. Sort Colors – Dutch National Flag algorithm for one-pass in-place sort. Top K Frequent Elements – HashMap + Heap or Bucket Sort. 💡 Key Takeaway: Mastering two-pointers, hashing, bucket sorting, and in-place operations makes array & string problems faster and more intuitive. 📌 All the practise is uploaded on my GitHub: https://lnkd.in/dEye4D2X #DSA #LeetCode #NeetCode #Algorithms #Coding #ProblemSolving #DataStructures

Binary Search is a powerful algorithm that efficiently finds an element in a sorted array by repeatedly dividing the search space in half. This approach significantly reduces time complexity compared to linear search. ✅ Problem: Binary Search 💻 Language: Java ⚡ Time Complexity: O(log n) Consistent practice is the key to mastering Data Structures & Algorithms. #LeetCode #BinarySearch #DSA #Java #Coding #ProblemSolving #SoftwareDevelopment

🚀 Day 6 of My DSA Journey – Mastering Patterns, Not Just Problems! Today I solved Two Sum II – Input Array is Sorted 🔢 💡 Key Insight: Two Pointer Pattern Instead of using a HashMap (O(n) space), I used the Two Pointer approach because the array is already sorted. 👉 Approach: Start with two pointers: left = 0 right = n - 1 Calculate sum: If sum == target → ✅ Found answer If sum < target → Move left++ If sum > target → Move right-- ⚡ Why this works? Because the array is sorted, we can intelligently move pointers to reduce time complexity. 📈 Complexity: Time: O(n) Space: O(1) 🧠 Pattern Learned: The Two Pointer Pattern is extremely powerful for: ✔ Sorted arrays ✔ Pair problems ✔ Optimization from brute force 💻 Tech Stack: Java | DSA | Problem Solving 🔥 Takeaway: Don’t just solve problems — identify patterns. That’s what turns practice into interview success. #DSA #Java #CodingJourney #LeetCode #SoftwareEngineer #ProblemSolving #TechCareers #100DaysOfCode

➕ DSA Practice — Sum of Digits (Recursive Approach) Today I solved the Sum of Digits problem using a recursive approach, focusing on breaking the problem into smaller subproblems. 🔍 Key Learnings Recursion works naturally when repeatedly reducing a number. Base case handles single-digit or zero condition. At each step, extract the last digit and recurse on the remaining number. Simple problems help strengthen core recursive thinking. 🧠 Why This Problem Matters Builds strong understanding of recursion fundamentals. Frequently asked as a basic interview or concept-check problem. Helps develop confidence in thinking step-by-step. 📌 Final Takeaway Even simple recursive problems are powerful for mastering base cases, shrinking input, and stack behavior. #dsa #recursion #mathematics #problemSolving #codingpractice #java #datastructures #interviewpreparation #algorithms #100DaysOfCode #softwareengineering

Day 18/100 of DSA , (Arrays) 🚀Toady I Solved: classic 3Sum problem — and it turned out to be more about thinking than just coding. 💡 At first, brute force (three nested loops) seemed simple. But O(n³) complexity clearly isn’t scalable. 🚫 Here’s what I applied: 🔹 Sorted the array 🔹 Fixed one element at a time 🔹 Used the Two Pointer technique 🔹 Carefully handled duplicates 🔹 Optimized time complexity to O(n²) What I learned today: Problem solving isn’t about memorizing answers. It’s about training your brain to recognize patterns and make logical decisions under constraints. 🧠 Small improvements in logic create big improvements in performance. 📈 Every DSA problem I practice is a step toward stronger fundamentals and better interview confidence. 🚀 #DSA #Java #ProblemSolving #InterviewPreparation #CodingJourney #FutureDeveloper

Classical Backtracking Problem with a Classical Approach Solved Word Search (LeetCode 79) using a clean and intuitive DFS + Backtracking strategy Approach (Simple & Clear): •Start from every cell that matches the first character of the word. •Use DFS (Depth-First Search) to explore all 4 directions (up, down, left, right). •Mark the current cell as visited (by replacing it temporarily) to avoid revisiting. •If the full word is matched → return true immediately. •Backtrack by restoring the cell when the path doesn’t work. Key Insight: We explore all possible paths, but prune early when characters don’t match — this keeps the solution efficient. ⏱️ Time Complexity: 👉 O(m × n × 4^L) •m × n → starting points •4^L → exploring 4 directions for each character of length L 📌 Space Complexity: 👉 O(L) (recursion stack) 🔥 Clean recursion + smart backtracking = problem cracked! #DSA #Backtracking #LeetCode #CodingInterview #Java #ProblemSolving

🚀 #60DaysOfLeetCode – Day 33 Today’s problem was Valid Parentheses, a classic stack-based problem that tests understanding of balanced expressions. 🔹 Approach Used: Stack Traverse the string character by character. Push all opening brackets (, {, [ onto the stack. For every closing bracket, check: If the stack is empty → invalid. Pop the top element and verify if it matches the corresponding opening bracket. At the end, if the stack is empty → the string is valid. 🔹 Key Learning: This problem reinforces how stacks help manage nested structures and order-sensitive operations. It’s a fundamental concept frequently asked in interviews. 🔹 Complexity: Time: O(n) Space: O(n) A simple yet powerful problem to strengthen core DSA concepts! 💻🔥 #LeetCode #DSA #Java #CodingChallenge #ProblemSolving #LearningInPublic #60DaysOfCode

🚀 Day 7 – LeetCode Practice Today, I solved the Next Permutation problem on LeetCode: 🎯 Difficulty: Medium 💻 Language Used: Java 💡 Approach: • Given an array of numbers, the task was to compute the next lexicographically greater permutation of those numbers. • If such a permutation isn’t possible, reorder it as the lowest possible order (ascending). • I followed the standard algorithm: – From the end, found the first pair where nums[i] < nums[i+1] — this is the pivot. – Then found the smallest number larger than the pivot from the right side. – Swapped the pivot and the next larger number. – Finally reversed the suffix to get the smallest greater permutation. ⏱ Complexity: • Time Complexity: O(n) • Space Complexity: O(1) 📚 Key Takeaway: This problem strengthened my understanding of permutation logic, lexicographical order, and in-place array manipulation. It’s a useful technique widely applicable in combinatorial problem solving. Consistent problem-solving practice continues to improve my algorithmic intuition and implementation skills. 💪 #LeetCode #Java #DSA #Arrays #Algorithms #ProblemSolving #CodingPractice #100DaysOfCode #SoftwareDeveloper