Solved LeetCode 160: Intersection of Two Linked Lists with Two Pointers

⚡ Day 97 of My LeetCode Journey — Problem 328: Odd Even Linked List 💡 Problem Insight: Today’s problem focused on rearranging a singly linked list so that all nodes at odd indices come first, followed by all even-indexed nodes — while maintaining their relative order. A great challenge to test how well you understand pointer manipulation! 🧠 Concept Highlight: The solution revolves around re-linking nodes using two pointers — one tracking odd nodes and another for even nodes. By carefully connecting them, we achieve the rearrangement in-place without extra space. It’s a smart exercise in linked list restructuring and pointer logic. 💪 Key Takeaway: Organizing efficiently — whether in data or in life — often means rearranging, not replacing. A small change in order can create big clarity. ✨ Daily Reflection: Linked lists truly train the mind to think sequentially and structurally — every link counts, just like every day of consistent learning. #Day97 #LeetCode #100DaysOfCode #LinkedList #ProblemSolving #DSA #CodingJourney #LearnByDoing #SoftwareEngineering #Pointers

🚀 Day 47 of Solving LeetCode – Slow Steps, Strong Patterns 🧩 Problem: Merge Two Sorted Lists A classic linked-list problem where you merge two already sorted lists into one sorted list. 🧠 Concepts / Techniques Used: Linked List manipulation Two-pointer technique Dummy node pattern Iterative merging logic ✨ Learning Reflection: Today’s problem reinforced how powerful the dummy node pattern is when working with linked lists. It not only simplifies edge cases but also keeps the code cleaner and easier to reason about. Every time I revisit linked list problems, I feel my confidence improving — one small win at a time. 📊 Performance Stats: 🏆 Runtime: 0 ms (Beats 100%) 💾 Memory: 17.96 MB 💡 Closing Line: Step by step, problem by problem — this journey is shaping me into a better thinker and engineer. Consistency always pays off. 🚀 🔖 Hashtags: #LeetCode #Day47 #DSA #LinkedList #100DaysOfCode #CodingJourney #SoftwareEngineering #ProblemSolving #MERN #AnkitCodes

💡 Day 78 of #100DaysOfCode 💡 🔹 Problem: Find Closest Number to Zero – LeetCode ✨ Approach: Traversed through the array while keeping track of the number closest to zero using absolute difference comparison. Handled ties by preferring the positive number — because even in code, positivity wins 😉 📊 Complexity Analysis: ⏱ Time Complexity: O(n) — single pass through the array 💾 Space Complexity: O(1) — no extra space used ✅ Runtime: 3 ms (Beats 44.80%) ✅ Memory: 46.87 MB 🔑 Key Insight: Even the smallest differences matter — especially when you’re finding what’s closest to zero! ⚡ #LeetCode #100DaysOfCode #DSA #ProblemSolving #CodingChallenge #JavaProgramming #AlgorithmDesign #CodeJourney #StayPositive

🔹 Day 70 of #100DaysOfLeetCodeChallenge 🔹 🚀 Problem: Combination Sum III 🔑 Topic: Backtracking 🧠 Approach: We need to find all combinations of k distinct numbers (1–9) that sum to n. Here’s how I solved it 👇 Use backtracking to explore all combinations starting from 1 to 9. Add the number and move forward recursively, reducing both k (count) and n (target). Stop when k == 0 and n == 0 → valid combination found! Backtrack by removing the last number and continue exploring. ⏳ Time Complexity: O(2⁹) ≈ O(512) 💾 Space Complexity: O(k) (recursion + temp list) 📌 Example: Input: k = 3, n = 9 Output: [[1,2,6],[1,3,5],[2,3,4]] ✅ 🎯 Takeaway: This problem teaches the power of controlled recursion — when both depth and sum conditions guide the search efficiently. 💡 #LeetCode #DSA #Backtracking #ProblemSolving #CodingChallenge #100DaysOfLeetCodeChallenge 🚀

💻 LeetCode Post — Day 3 of Week 2 #Learning_Of_DSA 🚀 Today’s #LeetCode_Problem_1 – Two Sum 💡 Today’s problem reminded me — simple logic can solve powerful challenges. The task? Given an array, find two numbers that add up to a target. At first glance, it looks easy — but efficiency matters when data grows big. ⚡ 🧠 Approach: Used a HashMap to store previously seen numbers and their indices. For every element, checked if (target - current) already exists in the map — if yes, we found our pair! Time complexity: O(n) — lightning-fast compared to the brute force O(n²). 💬 Takeaway: Problem-solving isn’t about memorizing patterns — it’s about thinking logically, efficiently, and scalably. Every question is another step toward writing code that thinks before it runs. 🚀 #LeetCode #DSA #LearnInPublic #ProblemSolving #CodingJourney #100DaysOfCode #SoftwareEngineering #MERNStack #CareerGrowth #TechWithPurpose

💻 Day 18 of My LeetCode Journey 🚀 Problem: LeetCode 2 — Add Two Numbers (Medium) 📘 Problem Overview: You are given two non-empty linked lists representing two non-negative integers. Each node in the lists contains a single digit, and the digits are stored in reverse order — meaning the 1’s place is at the head of the list. Your task is to add the two numbers and return the sum as a new linked list, also in reverse order. 💡 Key Learnings and Algorithmic Insights: 🔹 Core Concept: This problem is an excellent exercise in linked list traversal, digit-by-digit addition, and carry management, simulating manual addition in code form. 🔹 Approach: 1️⃣ Initialize a dummy node to construct the result list. 2️⃣ Use two pointers to traverse both linked lists simultaneously. 3️⃣ Maintain a carry variable to handle sums that exceed 9. 4️⃣ Continue until all digits and any remaining carry are processed. 🔹 Time Complexity: O(max(m, n)) — both lists are traversed once. 🔹 Space Complexity: O(max(m, n)) — for the resulting linked list. 🎯 Key Takeaway: This problem elegantly demonstrates how data structures can simulate real-world operations. It emphasizes careful pointer manipulation, iteration logic, and understanding of how information flows across linked nodes. Each problem in this journey reinforces the importance of clean logic, structured thinking, and consistency in learning. On to Day 19 💡 #LeetCode #Day18 #CodingChallenge #ProblemSolving #LinkedList #DSA #AlgorithmDesign #SoftwareEngineering #LearningEveryday #100DaysOfCode

🚀 Day 98 of My LeetCode Journey — Problem 19: Remove Nth Node From End of List 💡 Problem Insight: Today’s problem was about removing the n-th node from the end of a singly linked list. It’s a clean yet tricky problem that tests your understanding of linked list traversal, pointers, and edge case handling. 🧠 Concept Highlight: The most elegant solution uses the two-pointer technique: Move the fast pointer n steps ahead first. Then move both fast and slow pointers one step at a time until the fast pointer reaches the end. The slow pointer will be right before the node to delete. This ensures a single-pass (O(n)) solution — optimal and precise. 💪 Key Takeaway: It’s not always about rushing to the end — sometimes, starting with the right gap makes the journey efficient and smooth. ✨ Daily Reflection: Linked list problems continue to refine my logical precision and strengthen my foundation for advanced data structures. #Day98 #LeetCode #100DaysOfCode #LinkedList #TwoPointerTechnique #ProblemSolving #DSA #CodingJourney #LearnByDoing #SoftwareEngineering

🌟 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

🚀 Day 103 of My LeetCode Journey — Problem 61: Rotate List 💡 Problem Insight: Today’s problem was about rotating a linked list to the right by k places. That means shifting each node forward while the last node loops back to the head — a great test of both logic and pointer control. 🧠 Concept Highlight: The trick lies in: Connecting the list into a cycle (by linking the tail to the head). Finding the new head after length - (k % length) steps. Breaking the cycle to finalize the rotated list. This problem reinforces key ideas about circular linked lists, modular arithmetic, and efficient traversal. 💪 Key Takeaway: Rotation teaches that sometimes progress isn’t linear — moving in circles helps you find new beginnings in unexpected ways. ✨ Daily Reflection: Every linked list problem continues to refine my understanding of structure and precision — the true backbone of algorithmic thinking. #Day103 #LeetCode #100DaysOfCode #LinkedList #ProblemSolving #RotateList #TwoPointerTechnique #DSA #CodingJourney #LearnByDoing #SoftwareEngineering

#Day57 of my LeetCode Journey 🚀 Continuing with Linked List problems. 🧩 Question #160 – Intersection of Two Linked Lists (Easy) Brute Force Approach: 1) Traverse both linked lists and store nodes of the first list in a hash map.   2) Then, traverse the second list and check if any node already exists in the map.   3) The first repeated node is the intersection point.   - Time Complexity: O(N + M)   - Space Complexity: O(N)  Better Approach: 1) Find the lengths of both linked lists.   2) Calculate the difference between the two lengths.   3) Move the pointer of the longer list ahead by that difference.   4) Then move both pointers one step at a time until they meet.   5) The meeting point is the intersection node.   - Time Complexity: O(N + M)   - Space Complexity: O(1)  Optimal Approach (Two Pointer Technique): 1) Use two pointers, `t1` and `t2`, initialized at the heads of both lists.   2) Move both pointers one step at a time.   3) When one pointer reaches the end, redirect it to the head of the other list.   4) Eventually, both pointers will meet at the intersection node (or None if no intersection).   - Time Complexity: O(N + M)   - Space Complexity: O(1)  ✨ That’s it for Day 57. The journey continues — see you on Day 58. Happy coding! 🚀  #Day57 #LeetCodeJourney #LeetCode #LinkedList #Intersection #TwoPointerTechnique #DSA #PythonPrep