Middle Node of Linked List Java Solution

🚀 Day 21/40 – DSA Challenge 📌 LeetCode Problem – Median of Two Sorted Arrays 📝 Problem Statement Given two sorted arrays nums1 and nums2, find the median of the combined array. 📌 Example Input: nums1 = [1,2] nums2 = [3,4] Output: 2.5 💡 My Approach Instead of using complex binary search, I followed a simple and reliable method: 👉 Merge both arrays 👉 Sort the merged array 👉 Find the median This approach is easy to understand and implement. 🚀 Algorithm 1️⃣ Create a new array of size n1 + n2 2️⃣ Copy elements of both arrays 3️⃣ Sort the merged array 4️⃣ If length is odd → return middle element 5️⃣ If even → return average of two middle elements ✅ Java Code import java.util.Arrays; class Solution { public double findMedianSortedArrays(int[] nums1, int[] nums2) { int n1 = nums1.length; int n2 = nums2.length; int[] merged = new int[n1 + n2]; for (int i = 0; i < n1; i++) { merged[i] = nums1[i]; } for (int i = 0; i < n2; i++) { merged[n1 + i] = nums2[i]; } Arrays.sort(merged); int n = merged.length; if (n % 2 == 1) { return merged[n / 2]; } else { return (merged[n / 2 - 1] + merged[n / 2]) / 2.0; } } } ⏱ Complexity Time Complexity: O((n + m) log(n + m)) Space Complexity: O(n + m) 📚 Key Learnings – Day 21 ✔ Simple solutions are often easiest to implement ✔ Always understand problem constraints ✔ This problem can be optimized further using binary search ✔ Multiple approaches exist — choose based on context Simple approach. Clear logic. Strong understanding. Day 21 completed. Consistency continues 💪🔥 #180DaysOfCode #DSA #Java #InterviewPreparation #ProblemSolving #CodingJourney #Arrays #LeetCode

🚀 Day 31/40 – DSA Challenge 📌 LeetCode Problem – Mirror Distance of an Integer 📝 Problem Statement Given an integer n, compute its mirror distance: | n - reverse(n) | Where reverse(n) is formed by reversing the digits of n. 📌 Example Input: n = 25 Output: 27 Explanation: reverse(25) = 52 |25 - 52| = 27 💡 Key Insight The main task is correctly reversing the number. 👉 Extract digits one by one 👉 Build the reversed number ⚠️ Important: Do not lose the original value of n while reversing. 🚀 Algorithm 1️⃣ Store original value 2️⃣ Reverse the number using modulo and division 3️⃣ Return absolute difference ✅ Java Code (Correct & Safe) class Solution { public int mirrorDistance(int n) { int original = n; int reversed = 0; while (n != 0) { int digit = n % 10; reversed = reversed * 10 + digit; n /= 10; } return Math.abs(original - reversed); } } ⏱ Complexity Time Complexity: O(d) (d = number of digits) Space Complexity: O(1) ⚠️ Common Mistake (You Had This Earlier) return Math.abs(n - reversed); ❌ 👉 Because n becomes 0 after the loop ✔ Fix: return Math.abs(original - reversed); ✅ 📚 Key Learnings – Day 31 ✔ Preserve original values during transformations ✔ Digit extraction using % and / is fundamental ✔ Small mistakes can break correct logic ✔ Always dry run with simple inputs Simple problem. Careful implementation. Bug fixed, concept clear. Day 31 completed. Consistency continues 💪🔥 #180DaysOfCode #DSA #Java #InterviewPreparation #ProblemSolving #CodingJourney #Math #LeetCode

🚀 DAY 94/150 — CONNECTING TREE LEVELS! 🌳🔗 Day 94 of my 150 Days DSA Challenge in Java and today I solved a very interesting problem that focuses on level connections in Binary Trees 💻🧠 📌 Problem Solved: Populating Next Right Pointers in Each Node 📌 LeetCode: #116 📌 Difficulty: Medium 🔹 Problem Insight The task is to connect each node’s next pointer to its right node on the same level. If there is no right node → set next = null. 👉 This problem is based on a perfect binary tree, which allows some optimizations. 🔹 Approaches Used ✅ Approach 1: BFS (Level Order Traversal) • Use a queue to traverse level by level • Connect nodes within the same level using a prev pointer ✔️ Easy to understand ❌ Uses extra space (queue) ✅ Approach 2: Optimized (Constant Space) • Use already established next pointers • Connect: left → right right → next.left ✔️ No extra space (O(1)) ✔️ More optimized and elegant ⏱ Complexity Time Complexity: O(n) Space Complexity: • BFS → O(n) • Optimized → O(1) 🧠 What I Learned • Same problem can have multiple approaches (basic → optimized) • Perfect binary tree structure helps reduce complexity • Using existing pointers smartly can eliminate extra space 💡 Key Takeaway This problem taught me: How to connect nodes level-wise Difference between BFS vs pointer-based optimization Writing space-efficient solutions 🌱 Learning Insight Now I’m focusing more on: 👉 Moving from brute-force → optimized solutions 🚀 ✅ Day 94 completed 🚀 56 days to go 🔗 Java Solution on GitHub: 👉 https://lnkd.in/gDWj7K5Q 💡 Optimization is about using what you already have. #DSAChallenge #Java #LeetCode #BinaryTree #BFS #DFS #Pointers #150DaysOfCode #ProblemSolving #CodingJourney #InterviewPrep #LearningInPublic

📅 Date: April 27, 2026 Day 6 of my LeetCode Journey 🚀 ✅ Problem Solved: 14. Longest Common Prefix 🧠 Approach & Smart Solution: To solve this problem, I used a highly efficient Horizontal Scanning technique. Instead of comparing characters index by index across all strings, I assumed the very first string was the common prefix. Then, I iteratively compared it with the next strings, shaving off characters from the end until a match was found. By leveraging Java's built-in startsWith() method, the logic is kept clean and readable! • Pseudo-code: Assume the first string in the array is the initial 'prefix'. Loop through the rest of the strings in the array: While the current string does not start with the 'prefix': Shorten the 'prefix' by removing its last character. If the 'prefix' becomes completely empty, return "" (no common prefix exists). Return the final 'prefix' after checking all strings. This step-by-step reduction ensures we only do as much work as absolutely necessary. ⏱️ Time Complexity: O(S) (where S is the sum of all characters in all strings) 📦 Space Complexity: O(1) (Only modifying the prefix string, no extra arrays used) 📊 Progress Update: • Streak: 5 Days 🔥 • Difficulty: Easy • Pattern: String / Horizontal Scanning 🔗 LeetCode Profile: https://lnkd.in/gBcDQwtb (@Hari312004) Smartly utilizing built-in string methods like startsWith and substring can drastically reduce code complexity! 💡 #LeetCode #DSA #Strings #Java #CodingJourney #ProblemSolving #InterviewPrep #Consistency #BackendDevelopment

📅 Day 46/100 – LeetCode DSA Challenge 🧩 Problem: Longest Continuous Increasing Subsequence (674) 💡 Problem Summary Find the length of the longest continuous strictly increasing subarray. The sequence must be continuous, not just increasing elements from anywhere. 💡 My Approach I solved this problem by comparing each element with its next element: Initialized: count = 1 → current increasing sequence max = 1 → maximum length Traversed the array till n-1 to safely check nums[i+1] If nums[i] < nums[i+1] → increment count Else → reset count = 1 Continuously updated max using Math.max() This approach ensures we only consider continuous increasing sequences. 🧾 Code: class Solution { public int findLengthOfLCIS(int[] nums) { if(nums.length == 0) return 0; int count = 1; int max = 1; for(int i = 0; i < nums.length - 1; i++) { if(nums[i] < nums[i+1]) { count++; max = Math.max(count, max); } else { count = 1; } } return max; } } 📚 What I Learned How to safely use i+1 by controlling loop boundary Importance of handling edge cases (nums.length == 0) Difference between continuous vs non-continuous sequences Greedy approach for tracking subarray length Writing optimized O(n) solutions 🚀 Small improvements every day lead to big results! #Day46 #100DaysOfCode #LeetCode #DSA #Java #CodingJourney #ProblemSolving

🧠 LeetCode POTD — The Biggest Hint Was Hidden in One Line 1855. Maximum Distance Between a Pair of Values Today's problem looked tricky at first considering the time complexity. We need to find indices (i, j) such that: 👉 i <= j 👉 nums1[i] <= nums2[j] And maximize: 👉 j - i ━━━━━━━━━━━━━━━━━━━ My first instinct? Try brute force combinations. Check many pairs. Maybe binary search. But I was missing the most important line in the question: Both arrays are non-increasing (sorted). That one detail changes everything. ━━━━━━━━━━━━━━━━━━━ 💡 Once I noticed that, the solution became a clean two-pointer approach. Start with: 👉 i = 0 in nums1 👉 j = 0 in nums2 Then: If nums1[i] <= nums2[j] 👉 This pair is valid 👉 Update answer with j - i 👉 Move j forward to try for a bigger distance Else: 👉 Current i is too large 👉 Move i forward Because arrays are sorted, once a pair fails, moving i is the only useful move. ━━━━━━━━━━━━━━━━━━━ 📌 What I liked about this problem: The challenge wasn't the coding. It was reading carefully enough to spot the property that unlocks the solution. ✅ Sometimes the answer is already in the problem statement. ✅ You just have to notice it. Curious — did anyone else miss the sorted hint at first? 👀 #LeetCode #TwoPointers #ProblemSolving #SoftwareEngineering #DSA #Java #c++ #SDE

📘 DSA Journey — Day 31 Today’s focus: Binary Search for boundaries and square roots. Problems solved: • Sqrt(x) (LeetCode 69) • Search Insert Position (LeetCode 35) Concepts used: • Binary Search • Search space reduction • Boundary conditions Key takeaway: In Sqrt(x), the goal is to find the integer square root. Using binary search, we search in the range [1, x] and check mid * mid against x to narrow down the answer. This avoids linear iteration and achieves O(log n) time. In Search Insert Position, we use binary search to find either: • The exact position of the target, or • The correct index where it should be inserted The key idea is that when the target is not found, the final position of the left pointer gives the correct insertion index. These problems highlight how binary search is not just for finding elements, but also for determining positions and boundaries efficiently. Continuing to strengthen fundamentals and consistency in problem solving. #DSA #Java #LeetCode #CodingJourney

🚀 LeetCode — Problem 242 | Day 14 💡 Problem: Valid Anagram --- 🧠 Problem: Given two strings s and t, return true if t is an anagram of s, otherwise false. --- 🧠 Approach: - First check length: • If lengths differ → not an anagram - Use a frequency array of size 26 - Traverse both strings: • Increment count for s • Decrement count for t - Finally check: • If all values are 0 → valid anagram --- ⚙️ Core Logic: - freq[s.charAt(i) - 'a']++ - freq[t.charAt(i) - 'a']-- 👉 If all counts become zero → both strings have same characters --- ⏱ Time Complexity: O(n) 📦 Space Complexity: O(1) (fixed size array) --- ⚠️ Edge Cases: - Different lengths → false - Same characters, different order → true - Completely different strings → false --- 🔍 Insight: Instead of sorting, count character frequency --- 🔑 Key Learning: - Frequency counting is faster than sorting - Fixed-size array gives O(1) space - Simple and optimal approach for character problems --- "Compare frequency of characters using a fixed array instead of sorting." --- #LeetCode #DSA #Java #Strings #CodingJourney

🚀 Solved: Find Dominant Index (LeetCode) Just solved an interesting problem where the goal is to find whether the largest element in the array is at least twice as large as every other number. 💡 Approach: 1. First, traverse the array to find the maximum element and its index. 2. Then, iterate again to check if the max element is at least twice every other element. 3. If the condition fails for any element → return "-1". 4. Otherwise → return the index of the max element. 🧠 Key Insight: Instead of comparing all pairs, just track the maximum and validate it — keeps the solution clean and efficient. ⚡ Time Complexity: O(n) ⚡ Space Complexity: O(1) 💻 Code (Java): class Solution { public int dominantIndex(int[] nums) { int max = -1; int index = -1; // Step 1: find max and index for (int i = 0; i < nums.length; i++) { if (nums[i] > max) { max = nums[i]; index = i; } } // Step 2: check condition for (int i = 0; i < nums.length; i++) { if (i == index) continue; if (max < 2 * nums[i]) { return -1; } } return index; } } 🔥 Got 100% runtime and 99%+ memory efficiency! #LeetCode #DSA #Java #Coding #ProblemSolving #Algorithms

🚀 LeetCode Problem of the Day 📌 Problem: Minimum Distance to Target Element Given an integer array nums (0-indexed) and two integers target and start, we need to find an index i such that: nums[i] == target |i - start| is minimized 👉 Return the minimum absolute distance. 💡 Key Idea: We simply scan the array and track the minimum distance whenever we find the target. 🧠 Approach Traverse the array Whenever nums[i] == target, compute abs(i - start) Keep updating the minimum result 💻 Java Solution class Solution { public int getMinDistance(int[] nums, int target, int start) { int res = Integer.MAX_VALUE; for (int i = 0; i < nums.length; i++) { if (nums[i] == target) { res = Math.min(res, Math.abs(i - start)); } } return res; } } 📊 Complexity Analysis ⏱ Time Complexity: O(n) → single pass through the array 🧠 Space Complexity: O(1) → no extra space used ⚡ Simple linear scan, optimal solution — sometimes brute force is already the best solution! #LeetCode #Coding #Java #ProblemSolving #DataStructures #Algorithms #InterviewPrep