How to Remove Nth Node from End of Linked List

💡 𝐋𝐞𝐞𝐭𝐂𝐨𝐝𝐞 𝐃𝐚𝐢𝐥𝐲 𝐂𝐡𝐚𝐥𝐥𝐞𝐧𝐠𝐞 -𝟑𝟐𝟏𝟕. 𝐃𝐞𝐥𝐞𝐭𝐞 𝐍𝐨𝐝𝐞𝐬 𝐅𝐫𝐨𝐦 𝐋𝐢𝐧𝐤𝐞𝐝 𝐋𝐢𝐬𝐭 𝐏𝐫𝐞𝐬𝐞𝐧𝐭 𝐢𝐧 𝐀𝐫𝐫𝐚𝐲 🧩 Problem Summary: We are given a linked list and an array nums. The goal is to remove all nodes from the linked list whose values appear in nums, and then return the modified linked list. 🧠 Approach : • Store all elements from nums in an 𝐮𝐧𝐨𝐫𝐝𝐞𝐫𝐞𝐝_𝐬𝐞𝐭 for O(1) lookup. • Handle deletions from the beginning of the list (in case the head node’s value exists in nums). • Traverse the linked list and skip nodes whose values are present in the set. • Return the modified head of the list. 💨 Time Complexity: O(N + M) (where N = number of nodes in list, M = size of nums) 💾 Space Complexity: O(M) 🧩 Key Learning: • Efficient node deletion from a linked list becomes simpler when combined with hashing. • Using an unordered_set helps in quick membership checking and clean logic. #LeetCode #CodingChallenge #Leetcode #DataStructures #LinkedList #DSA #ProblemSolving #100DaysOfCode

🌟 Day 105 of My LeetCode Journey — Problem 138: Copy List with Random Pointer 💡 Problem Insight: Today’s problem took linked lists to a new level — each node had not just a next pointer but also a random pointer that could point to any node (or null). The challenge was to create a deep copy of such a list, preserving both connections perfectly. 🧠 Concept Highlight: The efficient approach involves three smart steps: Clone each node and insert it right next to the original node. Set up random pointers for the cloned nodes. Detach the two lists to restore the original and extract the copy. This clever interleaving technique avoids extra space (no hash map needed) and runs in O(n) time — an elegant display of pointer manipulation. 💪 Key Takeaway: Duplication isn’t about copying blindly — it’s about understanding the relationships and structure beneath the surface. ✨ Daily Reflection: This problem reinforced that clean logic and visualization make even the most pointer-heavy tasks simple and satisfying. #Day105 #LeetCode #100DaysOfCode #LinkedList #ProblemSolving #RandomPointer #DeepCopy #DSA #CodingJourney #LearnByDoing #SoftwareEngineering

🚀LeetCode Daily Challenge 🧩 Problem: Delete Nodes From Linked List Present in Array Problem Intuition: Given a linked list and an array of integers, you need to remove all nodes from the linked list whose values are present in the given array. In simple terms, delete every node that matches any number in the array and return the updated linked list. 💡Example Insight: Let’s say: nums = [1, 2, 3] Linked List = 1 → 2 → 4 → 3 → 5 After removing nodes with values 1, 2, and 3, the linked list becomes: 4 → 5 🧠 Approach & Strategy: ✔ Store all numbers from the array nums into an unordered_set for quick lookup (O(1) average). ✔ Traverse the linked list, and for each node: Skip it if its value is present in the set. Otherwise, add it to the new linked list. ✔ Finally, return the head of this new linked list. ⚙️ Complexity Analysis: Time Complexity: O(n + m) → n = length of linked list, m = size of array. Space Complexity: O(m) → For storing array elements in a set. 🔗 Problem: https://lnkd.in/dWA2hsDr 💻 Solution: https://lnkd.in/dypBvguK #LeetCode #DSA #Cpp #ProblemSolving #CodingChallenge #LeetCodeDailyChallenge

✅ #Day45 of #100DaysOfDSAChallenge 🔹 Problem Solved: 347. Top K Frequent Elements (LeetCode – Medium) 🔍 Approach: To find the K most frequent elements: Count Frequencies Use an unordered_map<int, int> to store the frequency of each number. Use Max-Heap Push {frequency, element} into a priority_queue (max-heap). Elements with higher frequency automatically come on top. Extract K Elements Pop the heap k times and store the element in the result list. ✅ This ensures we always take the highest-frequency elements first. ⏱️ Time Complexity: Building frequency map → O(n) Pushing into heap → O(m log m) (m = unique elements) Extracting k elements → O(k log m) Overall: O(n log n) in worst case. 📦 Space Complexity: Frequency map + heap → O(n) ✅ Concepts Practiced: Hash map Priority queue (max-heap) Frequency counting #Day45 #100DaysOfDSA #TopKFrequent #PriorityQueue #HashMap #DSA #CPP #LeetCode #ProblemSolving #CodingChallenge

🧩 LeetCode Challenge – Day 73 ✅ Worked on a linked list problem today — clean logic, but plenty of room for optimization. 🔗 LeetCode 3217 – Delete Nodes From Linked List Present in Array The goal was to remove nodes whose values appear in a given array. Instead of using hashing for lookups, I applied binary search after sorting the reference array — keeping the approach elegant and efficient. It was a great reminder that data structure choice can completely change a problem’s flow and clarity. 💡 Key Takeaways: • Binary search isn’t just for arrays — it enhances linked list problems too. • Efficiency through structure — sorted data can replace extra space usage. • Exploring alternatives deepens understanding far beyond standard templates. #Day73 #LeetCodeChallenge #100DaysOfCode #DSA #CodingJourney #ProblemSolving #LinkedList #BinarySearch #Pointers #DataStructures

🚀 #Day42 of 100DaysOfDSAChallenge 💡 Question: Delete Nodes From Linked List Present in Array (LeetCode – 3217) ⚙️ Approach: You’re given: A linked list. An array of integers (nums). The goal is to remove all nodes from the linked list whose values are present in nums. 🔍 Steps to Solve: First, store all numbers from the array nums into an unordered_set for O(1) lookups. Create a dummy node before the head to handle edge cases (like when the head needs to be deleted). Use two pointers: prev → points to the previous valid node. curr → traverses the list. If the value of curr exists in the set, skip that node by linking prev->next to curr->next. Otherwise, move prev forward. Continue until the list ends. Return the new list starting from dummy->next. ⏱ Time Complexity: O(N + M) N: Number of nodes in the linked list. M: Number of elements in nums. Building the set: O(M), Traversing the list: O(N). 💾 Space Complexity: O(M) For storing elements of nums in the unordered_set. ✅ Key Insight: Using a hash set allows constant-time checks for deletions and keeps the solution efficient — no nested loops or unnecessary traversal. 🏷️ Hashtags: #100DaysOfDSAChallenge #Day42 #LinkedList #LeetCode3217 #DataStructures #HashSet #CPlusPlus #ProblemSolving #DSA #CodingChallenge #LearnDSA #EfficientCode

🔥 Day 101 of My LeetCode Journey — Problem 160: Intersection of Two Linked Lists 💡 Problem Insight: Today’s problem focused on finding the intersection node of two singly linked lists — the node where both lists converge. It’s a classic problem that challenges logical reasoning and efficiency in linked list traversal. 🧠 Concept Highlight: The elegant solution uses two pointers, one starting at each list. When a pointer reaches the end, it jumps to the start of the other list. Eventually, both pointers will meet at the intersection node (or null if no intersection exists). This approach ensures O(n + m) time and O(1) space — a beautiful use of symmetry and synchronization in data traversal. 💪 Key Takeaway: Sometimes paths may seem different, but with persistence and alignment, they converge — both in code and in life. ✨ Daily Reflection: Starting the next 100 days with the same curiosity and determination. Every linked list teaches not just connections in data, but also connections in thought. #Day101 #LeetCode #100DaysOfCode #LinkedList #TwoPointerTechnique #ProblemSolving #DSA #CodingJourney #LearnByDoing #SoftwareEngineering #KeepCoding

🎯 LeetCode 700 – Search in a Binary Search Tree Today I spent some time revisiting the fundamentals of Binary Search Trees (BSTs) and solved LeetCode Problem 700. Even though this is considered an easy problem, I really like how it reinforces the core intuition behind BSTs. 🧩 Problem Insight: We are given the root of a Binary Search Tree and a value. The task is to find and return the node that contains this value. If the value doesn’t exist in the tree, we return null. What makes this problem interesting is not the complexity, but how naturally the BST structure guides the search process. 💡 Key Idea: In a Binary Search Tree, for any node: Left subtree values are smaller Right subtree values are greater This ordering means instead of searching the entire tree, we can decide the direction at each step: If the value we are searching for is smaller than the current node → move left If it’s greater → move right If it matches → we found it This makes the search efficient and elegant. The tree basically tells you where to go next. ⏱ Time Complexity: O(h) where h is the height of the tree (Best case: balanced tree. Worst case: skewed tree.)

🌟 #Day4 of #100DaysCodingChallenge 🌟 Problem: Count Elements With Maximum Frequency Platform: LeetCode 🧠 Problem Summary: Given an array of integers, the goal is to find how many elements appear with the maximum frequency. For example, if the array is [1, 2, 2, 3, 3], both 2 and 3 appear twice — the maximum frequency — so the output is 4 (because 2 and 3 each appear twice). ⚙️ Key Concepts: HashMap / Frequency map in C++ Counting occurrences efficiently Using loops and conditions to find max frequency 🎯 Goal of the Day: ✔ Strengthen problem-solving with maps ✔ Practice frequency-based questions ✔ Build confidence with array + hash map problems 🚀 Learning Never Stops! #Day4 #100DaysOfCode #LeetCode #CPP #ProblemSolving #WomenInTech #CodingJourney

🌟 Day 117 of 150 – Find Peak Element [LeetCode 162] 🌟 🔧 Problem Brief: You are given an integer array nums[], where a peak element is one that is strictly greater than its neighbors. Your task → Return the index of any peak element. You may assume that elements outside the array are -∞, i.e., nums[-1] = nums[n] = -∞. 🎯 Goal: Find any peak element using a binary search approach in O(log n) time ⏱. 🧠 How We Solve It? → Binary Search on Slopes 1️⃣ Initialize two pointers: left = 0, right = nums.length - 1 2️⃣ While left < right: Compute middle index → mid = (left + right) / 2 Compare middle element with its next neighbor: If nums[mid] > nums[mid + 1] → we are on a descending slope, so move left → right = mid Else → we are on an ascending slope, so move right → left = mid + 1 3️⃣ When the loop ends, left == right — this index is guaranteed to be a peak. 🧩 Example Walkthrough 📥 Input: nums = [1, 2, 3, 1] 📘 Steps: Start: left = 0, right = 3 mid = 1 → nums[mid]=2, nums[mid+1]=3 → ascending → left = 2 mid = 2 → nums[mid]=3, nums[mid+1]=1 → descending → right = 2 ✅ Output: 2 (index of peak element 3) 🧮 Complexity Analysis ⏱ Time Complexity: O(log n) 💾 Space Complexity: O(1) 📎 GitHub Link: https://lnkd.in/e5kCCFJY #Day117 #LeetCode #FindPeakElement #BinarySearch #JavaDSA #ProblemSolving #CodingChallenge #InterviewPrep #TechWithSaravana #150DaysOfCode #DSA #LearningJourney #CodeEveryday #Algorithm