Merge Two Sorted Lists in Java with LeetCode Solution

Day 26 of #100DaysOfLeetCode 💻✅ Solved #203. Remove Linked List Elements on LeetCode using Java. Approach: • Handled edge cases by removing matching nodes from the beginning of the list • Traversed the linked list using a pointer • Checked the next node’s value instead of the current node • If value matched, updated links to skip the node • Maintained in-place modification without using extra data structures Performance: ✓ Runtime: 1 ms (Beats 95.94% submissions) ✓ Memory: 47.62 MB Key Learning: ✓ Improved understanding of linked list pointer manipulation ✓ Learned how to handle head node edge cases carefully ✓ Strengthened in-place deletion logic in singly linked lists Learning one problem every single day 🚀 #Java #LeetCode #DSA #LinkedList #ProblemSolving #CodingJourney #100DaysOfCode

Day 23 of #100DaysOfLeetCode 💻✅ Solved #19. Remove Nth Node From End of List on LeetCode using Java. Approach: • Used a dummy node to handle edge cases (like removing the head) • Initialized two pointers: fast and slow • Moved fast pointer n+1 steps ahead to maintain a gap • Traversed both pointers together until fast reached null • Slow pointer stopped just before the node to delete • Updated links to remove the target node in one pass Performance: ✓ Runtime: 0 ms (Beats 100% submissions) ✓ Memory: 43.77 MB Key Learning: ✓ Mastered two-pointer (fast & slow) technique ✓ Understood importance of dummy node for edge cases ✓ Solved the problem in a single traversal (O(n) time, O(1) space) Consistency is building confidence 🚀 #Java #LeetCode #DSA #LinkedList #TwoPointers #ProblemSolving #100DaysOfCode

Day 14/100 – LeetCode Challenge 🚀 Problem: #169 Majority Element   Difficulty: Easy   Language: Java   Approach: Sorting + Middle Element   Time Complexity: O(n log n)   Space Complexity: O(1) 🔍 Key Insight: The majority element appears **more than ⌊n / 2⌋ times** in the array. If we **sort the array**, the majority element must occupy the **middle position** because it appears more than half of the time. Therefore, the element at index **n/2** will always be the majority element. 🧠 Solution Brief: First sorted the array using `Arrays.sort()`. Since the majority element appears more than half of the array length, it will always be positioned at the middle index. Finally returned `nums[nums.length / 2]` as the majority element. 📌 What I Learned: Understanding problem constraints can simplify the solution significantly. Sometimes a simple observation (like majority occupying the middle after sorting) can avoid more complex implementations. #LeetCode #Day14 #100DaysOfCode #Java #DSA #Arrays #ProblemSolving #CodingJourney

Day 21 of #100DaysOfLeetCode 💻✅ Solved #27. Remove Element problem on LeetCode in Java. Approach: • Used a two-pointer technique to modify the array in-place • Maintained a pointer k to place elements not equal to val • Iterated through the array and skipped elements equal to val • Placed non-val elements at the k-th position and incremented k • Returned k as the number of remaining elements Performance: ✓ Runtime: 0 ms (Beats 100% submissions) ✓ Memory: 44 MB (Beats ~75% submissions) Key Learning: ✓ Strengthened understanding of in-place array manipulation ✓ Learned how to skip unwanted elements efficiently ✓ Improved confidence in two-pointer techniques for array problems Learning one problem every single day 🚀 #Java #LeetCode #DSA #ProblemSolving #CodingJourney #100DaysOfCode

Day 36 of #100DaysOfLeetCode 💻✅ Solved #111. Minimum Depth of Binary Tree on LeetCode using Java. Approach: • Used recursive approach to calculate minimum depth • Returned 0 when root is null (base case) • If one subtree is null, avoided taking minimum of 0 (handled edge case carefully) • Returned 1 + minimum depth of valid subtree • Ensured correct handling of skewed trees Performance: ✓ Runtime: 6 ms ✓ Memory: 82.20 MB Key Learning: ✓ Understood difference between minimum depth and maximum depth logic ✓ Learned importance of handling null subtree cases correctly ✓ Improved confidence in solving binary tree recursion problems Learning one problem every single day 🚀 #Java #LeetCode #DSA #BinaryTree #Recursion #TreeProblems #ProblemSolving #CodingJourney #100DaysOfCode

Day 27 of #100DaysOfLeetCode 💻✅ Solved #83. Remove Duplicates from Sorted List on LeetCode using Java. Approach: • Utilized the fact that the linked list is already sorted • Traversed the list using a single pointer • Compared current node value with next node value • If duplicate found, skipped the next node by updating links • Continued traversal until reaching the end of the list Performance: ✓ Runtime: 0 ms (Beats 100% submissions) ✓ Memory: 45.30 MB (Beats 85.70% submissions) Key Learning: ✓ Understood how sorting simplifies duplicate removal logic ✓ Strengthened pointer manipulation skills in linked lists ✓ Learned efficient in-place modification without extra space Learning one problem every single day 🚀 #Java #LeetCode #DSA #LinkedList #ProblemSolving #CodingJourney #100DaysOfCode

Day 39 of #100DaysOfLeetCode 💻✅ Solved #258. Add Digits problem in Java. Approach: • Used a loop to repeatedly add all digits of the number • Extracted each digit using modulus (%) and divided the number by 10 • Stored the digit sum and repeated the process until the result became a single digit • Returned the final single digit as the answer Performance: ✓ Runtime: 1 ms (Beats 97.92% submissions) ✓ Memory: 42.52 MB Key Learning: ✓ Practiced digit extraction using modulus and division ✓ Understood how to repeatedly reduce a number to a single digit ✓ Strengthened problem-solving using loops and basic number manipulation Learning one problem every single day 🚀 #Java #LeetCode #DSA #ProblemSolving #CodingJourney #100DaysOfCode

Day 25 of #100DaysOfLeetCode 💻✅ Solved #167. Two Sum II – Input Array Is Sorted on LeetCode using Java. Approach: • Used Two Pointer technique since the array is already sorted • Initialized one pointer at the beginning and one at the end • Calculated the sum of both elements • If sum < target, moved left pointer forward • If sum > target, moved right pointer backward • Returned 1-based indices as required in the problem Performance: ✓ Runtime: 1 ms (Efficient with O(n) time complexity) ✓ Memory: Constant extra space (O(1)) Key Learning: ✓ Understood when to apply Two Pointer technique instead of HashMap ✓ Improved ability to optimize space complexity ✓ Strengthened pattern recognition for sorted array problems Learning one problem every single day 🚀 #Java #LeetCode #DSA #TwoPointers #ProblemSolving #CodingJourney #100DaysOfCode

Day 1/100 – LeetCode Challenge 🚀 Problem: #867 Transpose Matrix   Difficulty: Easy   Language: Java   Approach: Nested Loop with Index Swapping   Time Complexity: O(m × n)   Space Complexity: O(m × n) 🔍 Key Insight: The transpose of a matrix swaps rows and columns. If original matrix is m × n, the result will be n × m. Careful index handling is important to avoid dimension errors. 🧠 Solution Brief: Created a new matrix with reversed dimensions. Traversed the original matrix using nested loops. Assigned result[j][i] = matrix[i][j] to swap row and column indices. Returned the transposed matrix. this solution is basicaly bruteforce approach 📌 What I Learned: Even simple matrix problems improve understanding of 2D array traversal and index manipulation. Consistency starts today — 99 more days to go 💪 #LeetCode #Day1 #100DaysOfCode #Java #DSA #ProblemSolving #CodingJourney #LearningInPublic

Day 29 of #100DaysOfLeetCode 💻✅ Solved #22. Generate Parentheses on LeetCode using Java. Approach: • Used Backtracking to generate all valid combinations • Added "(" only if open brackets were available • Added ")" only when close brackets were greater than open • Ensured at every step that the parentheses remain balanced • Stopped recursion when both open and close counts reached zero Performance: ✓ Runtime: 3 ms (Beats 16.29% submissions) ✓ Memory: 45.18 MB (Beats 13.87% submissions) Key Learning: ✓ Strengthened understanding of Backtracking technique ✓ Learned how to maintain constraints during recursion ✓ Improved ability to build combinations using decision trees Learning one problem every single day 🚀 #Java #LeetCode #DSA #Backtracking #Recursion #ProblemSolving #CodingJourney #100DaysOfCode