Remove Nth Node from End of Linked List

Day 12/100 – LeetCode Challenge Problem: Middle of the Linked List Today’s problem focused on finding the middle node of a singly linked list. Approach: Used the Two-Pointer Technique (Slow & Fast pointers). slow moves one step at a time fast moves two steps at a time When fast reaches the end of the list, slow will be at the middle node Complexity: Time: O(n) Space: O(1) Concepts Practiced: Linked List traversal Two-pointer technique Efficient single-pass solution #100DaysOfCode #LeetCode #DSA #Java #LinkedList #ProblemSolving #CodingJourney

Solved "Container With Most Water" on LeetCode today using the Two-Pointer Technique. 🚀 The key insight is that the area formed by two lines depends on the shorter height and the distance between them. Starting with pointers at both ends of the array, we compute the area and move the pointer at the smaller height inward to potentially find a taller boundary and maximize the area. This approach efficiently reduces the problem from O(n²) brute force to O(n) time with O(1) space. Problems like this are a great reminder that the right observation can drastically optimize a solution. 💡 #LeetCode #DSA #TwoPointers #Java #ProblemSolving

Day 15/100 – LeetCode Challenge Problem: Reverse Linked List Today’s problem focused on reversing a singly linked list using an iterative approach. Approach: Used three pointers to reverse the links: prev → keeps track of the previous node curr → current node being processed next → stores the next node before changing the link Steps: Store curr.next in next Reverse the link → curr.next = prev Move prev and curr one step forward Continue until the list ends. Finally, prev becomes the new head of the reversed list. Complexity: Time: O(n) Space: O(1) Concepts Practiced: Linked List pointer manipulation Iterative reversal technique In-place algorithm #100DaysOfCode #LeetCode #DSA #Java #LinkedList #ProblemSolving #CodingJourney

The JVM still evolves. Modern vectorization techniques and the Vector API unlock serious performance improvements. Curious how Hotspot does it? Join the deep dive at Voxxed Days Zürich. 🎟️ https://lnkd.in/gQnKwUpy #Java #JVM #VDZ26

Day 63 - Odd Even Linked List Today’s problem was about rearranging nodes based on their positions. Approach: • Maintain two pointers → odd and even • Traverse and rearrange links in-place • Keep track of even head to attach later • Merge odd list with even list at the end Key insight: 👉 Focus on node positions, not node values. Time Complexity: O(n) Space Complexity: O(1) #Day63 #LeetCode #Java #LinkedList #CodingPractice #TechJourney #DSA

🚀 Day #82/100 – 𝐑𝐞𝐦𝐨𝐯𝐞 𝐄𝐥𝐞𝐦𝐞𝐧𝐭 (LeetCode) Today’s problem was Remove Element — a simple yet important question to understand in-place array manipulation. 🔍 𝐊𝐞𝐲 𝐋𝐞𝐚𝐫𝐧𝐢𝐧𝐠: We don’t need extra space! We can solve this using a two-pointer approach efficiently.  𝐖𝐡𝐲 𝐢𝐭 𝐰𝐨𝐫𝐤𝐬? We overwrite unwanted elements and keep only the valid ones at the beginning of the array. ⚡ 𝐀𝐩𝐩𝐫𝐨𝐚𝐜𝐡: Initialize k = 0 Traverse array: If element ≠ val → place it at index k Increment k Return k (new length) ⏱️ 𝐓𝐢𝐦𝐞 𝐂𝐨𝐦𝐩𝐥𝐞𝐱𝐢𝐭𝐲: O(n) 📦 𝐒𝐩𝐚𝐜𝐞 𝐂𝐨𝐦𝐩𝐥𝐞𝐱𝐢𝐭𝐲: O(1) #Day82 #100DaysOfCode #Java #DSA #LeetCode #TwoPointers #CodingJourney

Leetcode problem : 16🚀 3Sum Closest – Today I’m sharing the core logic of the 3Sum Closest problem in a very simple way. First, we sort the array so that using the two-pointer technique becomes easier. Then we fix one number (k) and use two pointers (left and right) to find the other two numbers. At each step, we calculate the sum of three numbers (currentSum) and check how close it is to the target. If this sum is closer to the target than the previous closestSum, we update closestSum. Then we move the pointers based on the comparison: If currentSum < target → move left++ (we need a bigger sum) If currentSum > target → move right-- (we need a smaller sum) If currentSum == target → return immediately Finally, we return the sum that is closest to the target. #LeetCode #DSA #ThreeSumClosest #TwoPointer #Java #ProblemSolving 🚀

🚀 LeetCode #19 — Remove Nth Node From End of List Linked List problem ✔️ 👉 Remove the Nth node from the end of a linked list 📌 Example: Input: [1,2,3,4,5], n = 2 Output: [1,2,3,5] 💡 Approach (intuitive): • First, calculate the length of the list • Find the (len - n)th node • Update its next pointer to skip the target node 🧠 Edge Case: If the head itself needs to be removed → return head.next ⏱ Time: O(n) 📦 Space: O(1) #DSA #LeetCode #Java #LinkedList #InterviewPrep #CodingJourney

Day 60 - Remove Duplicates from Sorted List Worked on removing duplicate elements from a sorted linked list. Approach: • Traverse the list once • Compare current node with next node • Skip duplicate nodes by adjusting pointers Time Complexity: O(n) Space Complexity: O(1) #Day60 #LeetCode #Java #LinkedList #CodingPractice #DSA #TechJourney

Day: 78/365 📌 LeetCode POTD: Equal Sum Grid Partition I Medium Key takeaways/Learnings from this problem: 1. This problem highlights how prefix sums make grid partitioning super efficient instead of recalculating sums again and again. 2. The key is trying splits smartly (row-wise or column-wise) and checking if both parts can balance out. 3. It’s a good reminder that many 2D problems become easier when you reduce them to 1D cumulative sums. #POTD #365DaysOfCode #DSA #Java #ProblemSolving #LearningInPublic #Consistency 🥷