Remove Nth Node From End of Linked List in Java

Many linked list problems are about pointer manipulation and maintaining order. 🚀 Day 113/365 — DSA Challenge Solved: Merge Two Sorted Lists Problem idea: We are given two sorted linked lists, and we need to merge them into a single sorted list. Efficient approach: Use a two-pointer technique to compare elements and build the merged list. Steps: 1. Create a dummy node to simplify result construction 2. Compare current nodes of both lists 3. Attach the smaller node to the result 4. Move the corresponding pointer forward 5. Once one list ends, attach the remaining part of the other list This ensures the final list remains sorted. ⏱ Time: O(n + m) 📦 Space: O(1) Day 113/365 complete. 💻 252 days to go. Code: https://lnkd.in/dad5sZfu #DSA #Java #LinkedList #LeetCode #LearningInPublic

Linked list problems often test how well you can manipulate pointers without losing track. 🚀 Day 114/365 — DSA Challenge Solved: Swap Nodes in Pairs Problem idea: We need to swap every two adjacent nodes in a linked list without changing values, only pointers. Efficient approach: Use a dummy node and carefully adjust pointers in pairs. Steps: 1. Use a dummy node pointing to head 2. Maintain a pointer prev before the current pair 3. Identify two nodes: first and second 4. Swap them by updating pointers 5. Move prev forward to the next pair This ensures all pairs are swapped correctly. ⏱ Time: O(n) 📦 Space: O(1) Day 114/365 complete. 💻 251 days to go. Code: https://lnkd.in/dad5sZfu #DSA #Java #LinkedList #LeetCode #LearningInPublic

Some linked list problems are all about reversing connections in a controlled range. 🚀 Day 115/365 — DSA Challenge Solved: Reverse Linked List II Problem idea: We need to reverse a portion of a linked list from position left to right, while keeping the rest unchanged. Efficient approach: Use in-place reversal with pointer manipulation. Steps: 1. Use a dummy node to simplify edge cases 2. Move a pointer to the node just before position left 3. Start reversing nodes one by one within the range 4. Adjust links so that reversed nodes are inserted at the correct position 5. Connect the reversed portion back to the list This avoids creating extra space and keeps the solution efficient. ⏱ Time: O(n) 📦 Space: O(1) Day 115/365 complete. 💻 250 days to go. Code: https://lnkd.in/dad5sZfu #DSA #Java #LinkedList #LeetCode #LearningInPublic

Sometimes linked list problems become simple when you convert them into a circular structure. 🚀 Day 116/365 — DSA Challenge Solved: Rotate List Problem idea: We need to rotate a linked list to the right by k positions. Efficient approach: Convert the list into a circular linked list, then break it at the right point. Steps: 1. Find the length of the list 2. Compute effective rotations → k % length 3. Connect the last node to the head (make it circular) 4. Find the new tail → (length − k) steps 5. Break the circle and update head This avoids repeated rotations and keeps it efficient. ⏱ Time: O(n) 📦 Space: O(1) Day 116/365 complete. 💻 249 days to go. Code: https://lnkd.in/dad5sZfu #DSA #Java #LinkedList #LeetCode #LearningInPublic

Some linked list problems go beyond simple pointers — they test how you handle multiple relationships between nodes. 🚀 Day 117/365 — DSA Challenge Solved: Copy List with Random Pointer Problem idea: We need to create a deep copy of a linked list where each node has an additional random pointer. Efficient approach: Use a HashMap to map original nodes to copied nodes. Steps: 1. Traverse the list and create a copy of each node 2. Store mapping: original → copy 3. Traverse again to assign next and random pointers 4. Return the copied head This ensures all pointers in the new list correctly reference copied nodes. ⏱ Time: O(n) 📦 Space: O(n) Day 117/365 complete. 💻 248 days to go. Code: https://lnkd.in/dad5sZfu #DSA #Java #LinkedList #HashMap #LeetCode #LearningInPublic

Day 71 - Delete Middle Node Handling linked list traversal to identify and remove the middle node efficiently. Approach: • Traverse once to count nodes • Find middle index using n/2 • Traverse again to reach previous node • Update pointers to remove middle Key Insight: Careful handling needed when list size is small (edge cases) Time Complexity: O(n) Space Complexity: O(1) #Day71 #LeetCode #Java #CodingPractice #TechJourney #DSA #LinkedList

🚀 𝐃𝐚𝐲 91/100 – 𝐌𝐚𝐱 𝐂𝐨𝐧𝐬𝐞𝐜𝐮𝐭𝐢𝐯𝐞 𝐎𝐧𝐞𝐬  🔍 𝐊𝐞𝐲 𝐋𝐞𝐚𝐫𝐧𝐢𝐧𝐠: Keeping track of a running count helps efficiently solve problems involving continuous sequences. 💡 𝐂𝐨𝐫𝐞 𝐈𝐝𝐞𝐚: Traverse the array Count consecutive 1s Reset count when 0 appears Track maximum count  𝐖𝐡𝐲 𝐢𝐭 𝐰𝐨𝐫𝐤𝐬? We only care about continuous 1s, so resetting on 0 ensures we start counting a new sequence. ⚡ 𝐀𝐩𝐩𝐫𝐨𝐚𝐜𝐡: Initialize count = 0 and max = 0 Loop through array: If 1 → increment count Else → reset count Update max at each step ⏱️ Time Complexity: O(n) 📦 Space Complexity: O(1) #Day91 #100DaysOfCode #Java #DSA #LeetCode #Arrays #CodingJourney

Day 66 — LeetCode Progress (Java) Problem: Find the Difference of Two Arrays Required: Given two integer arrays, return: Elements present in nums1 but not in nums2 Elements present in nums2 but not in nums1 Idea: Use sets to remove duplicates and quickly check membership. Approach: Convert both arrays into sets Iterate over nums1 set: Add elements not present in nums2 set to result1 Iterate over nums2 set: Add elements not present in nums1 set to result2 Return both lists Time Complexity: O(n + m) Space Complexity: O(n + m) #LeetCode #DSA #Java #HashSet #Arrays #ProblemSolving #CodingJourney

🚀𝐃𝐚𝐲 88/100 – 𝐀𝐝𝐝 𝐁𝐢𝐧𝐚𝐫𝐲 Today’s problem was Add Binary — a great exercise to understand how addition works at the binary level. 🔍 𝐊𝐞𝐲 𝐋𝐞𝐚𝐫𝐧𝐢𝐧𝐠: Just like decimal addition, binary addition also uses a carry, but with base 2. 💡 𝐂𝐨𝐫𝐞 𝐈𝐝𝐞𝐚: Traverse both strings from right to left Add digits along with carry Append result and update carry  𝐖𝐡𝐲 𝐢𝐭 𝐰𝐨𝐫𝐤𝐬? Binary addition rules: 0 + 0 = 0 1 + 0 = 1 1 + 1 = 0 (carry 1) ⚡ 𝐀𝐩𝐩𝐫𝐨𝐚𝐜𝐡: Use two pointers (end of both strings) Add digits + carry Append (sum % 2) Update carry (sum / 2) Reverse the result ⏱️ 𝐓𝐢𝐦𝐞 𝐂𝐨𝐦𝐩𝐥𝐞𝐱𝐢𝐭𝐲: 𝐎(𝐦𝐚𝐱(𝐧, 𝐦)) 📦 𝐒𝐩𝐚𝐜𝐞 𝐂𝐨𝐦𝐩𝐥𝐞𝐱𝐢𝐭𝐲: 𝐎(𝐧) #Day88 #100DaysOfCode #Java #DSA #LeetCode #Strings #CodingJourney

Some of the hardest problems become manageable once you recognize a repeating pattern. 🚀 Day 105/365 — DSA Challenge Solved: Subarrays with K Different Integers Problem idea: We need to count subarrays that contain exactly k distinct integers. Efficient approach: Use the powerful trick: subarrays with exactly k distinct = subarrays with ≤ k distinct − subarrays with ≤ (k − 1) distinct Steps: 1. Use a sliding window with a hashmap to track frequency of elements 2. Expand window by moving right pointer 3. If distinct count exceeds k, shrink window from the left 4. Count valid subarrays ending at each index 5. Subtract results to get exact count This pattern converts a hard problem into a manageable one. ⏱ Time: O(n) 📦 Space: O(n) Day 105/365 complete. 💻 260 days to go. Code: https://lnkd.in/dad5sZfu #DSA #Java #SlidingWindow #HashMap #LeetCode #LearningInPublic