Rotating Linked List with Circular Structure

Linked list problems often become simpler when you break them into clear steps. 🚀 Day 111/365 — DSA Challenge Solved: Remove Nth Node From End of List Problem idea: We need to remove the nth node from the end of a linked list. Efficient approach: Convert the problem into finding the (size − n)th node from the start. Steps: 1. Traverse the list to calculate its size 2. If n equals size → remove the head 3. Otherwise, find the node just before the target 4. Update pointers to remove the node This simplifies the problem using basic traversal and pointer manipulation. ⏱ Time: O(n) 📦 Space: O(1) Day 111/365 complete. 💻 254 days to go. Code: https://lnkd.in/dad5sZfu #DSA #Java #LinkedList #LeetCode #LearningInPublic

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

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 65/75 — Count Pairs Whose Sum is Less than Target Today’s problem was a clean application of sorting + two pointers. Approach: • Sort the array • Use two pointers (i at start, j at end) • If nums[i] + nums[j] < target → all pairs between i and j are valid • Add (j - i) to count and move i forward • Otherwise, move j backward Key idea: if(nums.get(i) + nums.get(j) < target)  count += (j - i); Time Complexity: O(n log n) (sorting) Space Complexity: O(1) This pattern shows up a lot in pair-based problems — very important to master. 65/75 🔥 #Day65 #DSA #TwoPointers #Sorting #Java #LeetCode

Many subarray problems follow the same hidden pattern — once you recognize it, they become much easier. 🚀 Day 102/365 — DSA Challenge Solved: Count Number of Nice Subarrays Problem idea: We need to count the number of subarrays that contain exactly k odd numbers. Efficient approach: Use the same trick as previous problem: subarrays with exactly k odds = subarrays with ≤ k odds − subarrays with ≤ (k − 1) odds Steps: 1. Use a sliding window to count subarrays with at most k odd numbers 2. Expand window by moving right pointer 3. If odd count exceeds k, shrink window from left 4. Add valid subarrays ending at each index 5. Subtract results to get exact count This pattern works beautifully for binary-like conditions. ⏱ Time: O(n) 📦 Space: O(1) Day 102/365 complete. 💻 263 days to go. Code: https://lnkd.in/dad5sZfu #DSA #Java #SlidingWindow #LeetCode #LearningInPublic

🖤 Day 46 of Solving DSA : Four Sum------> Check Array Length: First, check if the length of the input array is less than 4. If yes, return an empty array or list because we can't form a valid group of 4 elements. Sort the Array: Sort the array in ascending order. Sorting helps us manage duplicates and makes it easier to work with combinations. Find Unique Combinations: Use a loop to go through the array and look for groups of 4 numbers. While looping, skip any duplicates by using an if condition to check if the current number is the same as the previous one. Store Results: For each valid group of 4 numbers without duplicates, add it to the result list. Return the Result: After completing the loops, return the list of unique combinations. Complexity Time complexity:O(n3) Space complexity:O(k) #DSA #java #logicalThinking #100dayschalleng #consistency #leetcode #tuf #striverSheet

Linked list problems often simulate real-world processes — this one is just like manual addition. 🚀 Day 112/365 — DSA Challenge Solved: Add Two Numbers Problem idea: We are given two numbers in reverse order as linked lists, and we need to return their sum as a linked list. Efficient approach: Simulate the addition process digit by digit with a carry. Steps: 1. Traverse both linked lists simultaneously 2. Add corresponding digits along with carry 3. Create a new node with (sum % 10) 4. Update carry = sum / 10 5. Continue until both lists and carry are exhausted Using a dummy node helps simplify list construction. ⏱ Time: O(max(n, m)) 📦 Space: O(max(n, m)) Day 112/365 complete. 💻 253 days to go. Code: https://lnkd.in/dad5sZfu #DSA #Java #LinkedList #LeetCode #LearningInPublic

Some subarray counting problems become much easier when we transform them into “at most” problems. 🚀 Day 101/365 — DSA Challenge Solved: Binary Subarrays With Sum Problem idea: We need to count the number of subarrays whose sum equals a given goal in a binary array. Efficient approach: Instead of directly counting subarrays with exact sum, we use a trick: subarrays with sum = goal = subarrays with sum ≤ goal − subarrays with sum ≤ (goal − 1) Steps: 1. Create a helper function to count subarrays with sum at most k 2. Use a sliding window to maintain a valid window where sum ≤ k 3. Add the number of valid subarrays ending at each index 4. Subtract results to get the exact count for the goal This converts the problem into an efficient sliding window solution. ⏱ Time: O(n) 📦 Space: O(1) Day 101/365 complete. 💻 264 days to go. Code: https://lnkd.in/dad5sZfu #DSA #Java #SlidingWindow #LeetCode #LearningInPublic