Skip to content
QuizMaker logoQuizMaker
Activity
DSA Course: Interview Patterns and Problem Solving
Module 5: Linked List
Best Time to Buy and Sell Stock: Greedy Pattern
Maximum Subarray: Kadane Pattern
Move Zeroes: Two pointers Pattern
Contains Duplicate: Set Pattern
Valid Anagram: Frequency map Pattern
Longest Substring Without Repeating Characters: Sliding window Pattern
Valid Palindrome: Two pointers Pattern
Longest Palindromic Substring: Expand around center Pattern
Group Anagrams: Hash key Pattern
Binary Search: Classic search Pattern
Search Insert Position: Lower bound Pattern
First Bad Version: Predicate search Pattern
Search in Rotated Sorted Array: Rotated search Pattern
Find Minimum in Rotated Sorted Array: Rotated minimum Pattern
Valid Parentheses: Stack matching Pattern
Min Stack: Auxiliary stack Pattern
Daily Temperatures: Monotonic stack Pattern
Next Greater Element I: Monotonic stack Pattern
Evaluate Reverse Polish Notation: Stack evaluation Pattern
Reverse Linked List: Pointer reversal Pattern
Merge Two Sorted Lists: Dummy node Pattern
Linked List Cycle: Fast and slow pointers Pattern
Middle of the Linked List: Fast and slow pointers Pattern
Remove Nth Node From End: Two pointers Pattern
Binary Tree Traversals: DFS recursion Pattern
Maximum Depth of Binary Tree: Height recursion Pattern
Binary Tree Level Order Traversal: BFS queue Pattern
Validate Binary Search Tree: Range bounds Pattern
Lowest Common Ancestor: Recursive split Pattern
Connected Components: Adjacency DFS Pattern
Number of Islands: Grid DFS Pattern
Flood Fill: Boundary DFS Pattern
Clone Graph: Hash Map DFS Pattern
Course Schedule: Topological Sort Pattern
Union Find Components: Disjoint Set Pattern
Shortest Path in Unweighted Graph: BFS Distance Pattern
Climbing Stairs: Fibonacci DP Pattern
House Robber: Pick or Skip DP Pattern
Coin Change: Minimum Coins DP Pattern
Longest Increasing Subsequence: Binary Search DP Pattern
Longest Common Subsequence: 2D DP Pattern
0/1 Knapsack: Capacity DP Pattern
Longest Consecutive Sequence: Hash Set Pattern
Subarray Sum Equals K: Prefix Sum Hashmap Pattern
First Unique Character: Frequency Map Pattern
Find Duplicates: Frequency Map Pattern
Ransom Note: Character Availability Pattern
Sort Colors: Dutch National Flag Pattern
Next Permutation: Pivot and Suffix Reversal Pattern
Merge Intervals: Sort and Sweep Pattern
Find First and Last Position: Boundary Binary Search Pattern
Search a 2D Matrix: Flattened Binary Search Pattern
Subsets: Pick or Skip Recursion Pattern
Generate Parentheses: Valid State Backtracking Pattern
Combination Sum: Reuse Choice Backtracking Pattern
N-Queens: Constraint Backtracking Pattern
Word Search: Grid Backtracking Pattern
Kth Largest Element: Size-K Min-Heap Pattern
Top K Frequent Elements: Frequency Heap Pattern
Merge K Sorted Lists: Min-Heap Multiway Merge Pattern
Median Finder: Two Heaps Pattern
Task Scheduler: Greedy Max-Heap Pattern
Jump Game: Farthest Reach Greedy Pattern
Gas Station: Greedy Reset Pattern
Non-overlapping Intervals: Earliest End Greedy Pattern
Minimum Arrows to Burst Balloons: Interval End Greedy Pattern
Partition Labels: Last Occurrence Greedy Pattern
Single Number: XOR Cancellation Pattern
Power of Two: n and n-1 Pattern
Number of 1 Bits: Brian Kernighan Pattern
Single Number III: Rightmost Set Bit Pattern
XOR From 1 to N: Modulo Cycle Pattern
Prime Check: Square Root Trial Division Pattern
Sieve of Eratosthenes: Prime Marking Pattern
GCD: Euclidean Remainder Pattern
Binary Exponentiation: Fast Power Pattern
Modular Inverse: Extended Euclid Pattern
Implement Trie: Prefix Tree Pattern
Longest Common Prefix: Single Branch Trie Pattern
LRU Cache: Hash Map Plus Recency List Pattern
Segment Tree: Range Sum Query Pattern
Fenwick Tree: Binary Indexed Prefix Sum Pattern
CONTENTS

Merge Two Sorted Lists: Dummy node Pattern

Use a dummy node and tail pointer to merge two sorted linked lists cleanly.

DSA Course: Interview Patterns and Problem Solving
Module 5: Linked List
dsa
data structures and algorithms
+4
May 28, 2026
30
A

Learning Outcome

After this lesson, you should be able to merge two sorted linked lists by attaching the smaller current node to a result list.

Problem Statement

Given the heads of two sorted linked lists, merge them into one sorted linked list and return its head.

InputOutputWhy
1 -> 2 -> 4 and 1 -> 3 -> 41 -> 1 -> 2 -> 3 -> 4 -> 4Nodes are merged in nondecreasing order.

Brute Force Approach

Copy all values into an array, sort the array, and build a new linked list.

This works, but it wastes the fact that both lists are already sorted and uses extra space.

Optimized Approach

Use a dummy node before the answer and a tail pointer. Compare the current nodes of both lists, attach the smaller node to tail.next, then move that list forward.

When one list finishes, attach the remaining part of the other list directly.

Exact Pseudocode

dummy = new node
tail = dummy
while list1 is not null and list2 is not null:
  if list1.val <= list2.val:
    tail.next = list1
    list1 = list1.next
  else:
    tail.next = list2
    list2 = list2.next
  tail = tail.next
tail.next = list1 if list1 is not null else list2
return dummy.next

Reference Code

class Solution:
    def mergeTwoLists(self, list1, list2):
        dummy = ListNode(0)
        tail = dummy

        while list1 and list2:
            if list1.val <= list2.val:
                tail.next = list1
                list1 = list1.next
            else:
                tail.next = list2
                list2 = list2.next
            tail = tail.next

        tail.next = list1 if list1 else list2
        return dummy.next

Sample Dry Run

list1list2Attachmerged
11list1's 11
21list2's 11 -> 1
2321 -> 1 -> 2
4331 -> 1 -> 2 -> 3
44Attach remaining1 -> 1 -> 2 -> 3 -> 4 -> 4

Complexity

MeasureValueReason
TimeO(n + m)Each node from both lists is visited once.
SpaceO(1)The nodes are reused; only pointers are stored.

Edge Cases

  • One list is empty.
  • Both lists are empty.
  • Duplicate values appear in both lists.

Interview Checklist

  • Use a dummy node to avoid special-casing the head.
  • Move tail after every attachment.
  • Attach the remaining list at the end.

FAQs

Why use a dummy node?

It gives a stable node before the answer so the first attachment uses the same logic as every later attachment.

Do we create new nodes?

The optimized version reuses existing nodes by changing links.

What is the core pattern?

Dummy node plus tail pointer.

Share this article

Share on TwitterShare on LinkedInShare on FacebookShare on WhatsAppShare on Email

Test your knowledge

Take a quick quiz based on this chapter.

easyDSA Course
Merge Two Sorted Lists - Dummy node Pattern Practice Quiz
5 questions8 min

0 comments

Please login to comment.
No comments yet.
Lesson 2 of 5 in Module 5: Linked List
Previous in Module 5: Linked List
Reverse Linked List: Pointer reversal Pattern
Next in Module 5: Linked List
Linked List Cycle: Fast and slow pointers Pattern
Back to DSA Course: Interview Patterns and Problem Solving
Back to moduleCategories