Merge K Sorted Lists Using Min Heap in DSA Go - Execution Trace

Concept Flow - Merge K Sorted Lists Using Min Heap

Create min heap

↓

Insert first node of each list into heap

↓

While heap not empty

↓

Extract min node from heap

↓

Add min node to merged list

↓

If min node has next, insert next into heap

↓

Repeat until heap empty

↓

Return merged list head

We build a min heap with the first nodes of all lists, then repeatedly extract the smallest node, add it to the merged list, and insert the next node from that list into the heap until all nodes are merged.

Execution Sample

DSA Go

lists = [[1,4,5],[1,3,4],[2,6]]
minHeap = []
for each list:
  insert first node into minHeap
while minHeap not empty:
  node = extract min
  add node to merged list
  if node.next:
    insert node.next into minHeap

This code merges 3 sorted lists by always picking the smallest current node using a min heap.

Execution Table

Step	Operation	Nodes in Heap	Extracted Node	Heap After Extract	Merged List State
1	Insert first nodes	[1(L1),1(L2),2(L3)]	None	[1(L1),1(L2),2(L3)]	Empty
2	Extract min	[1(L1),1(L2),2(L3)]	1(L1)	[1(L2),2(L3)]	1
3	Insert next of extracted	[1(L2),2(L3),4(L1)]	None	[1(L2),2(L3),4(L1)]	1
4	Extract min	[1(L2),2(L3),4(L1)]	1(L2)	[2(L3),4(L1)]	1 -> 1
5	Insert next of extracted	[2(L3),3(L2),4(L1)]	None	[2(L3),3(L2),4(L1)]	1 -> 1
6	Extract min	[2(L3),3(L2),4(L1)]	2(L3)	[3(L2),4(L1)]	1 -> 1 -> 2
7	Insert next of extracted	[3(L2),4(L1),6(L3)]	None	[3(L2),4(L1),6(L3)]	1 -> 1 -> 2
8	Extract min	[3(L2),4(L1),6(L3)]	3(L2)	[4(L1),6(L3)]	1 -> 1 -> 2 -> 3
9	Insert next of extracted	[4(L1),4(L2),6(L3)]	None	[4(L1),4(L2),6(L3)]	1 -> 1 -> 2 -> 3
10	Extract min	[4(L1),4(L2),6(L3)]	4(L1)	[4(L2),6(L3)]	1 -> 1 -> 2 -> 3 -> 4
11	Insert next of extracted	[4(L2),5(L1),6(L3)]	None	[4(L2),5(L1),6(L3)]	1 -> 1 -> 2 -> 3 -> 4
12	Extract min	[4(L2),5(L1),6(L3)]	4(L2)	[5(L1),6(L3)]	1 -> 1 -> 2 -> 3 -> 4 -> 4
13	Insert next of extracted	[5(L1),6(L3)]	None	[5(L1),6(L3)]	1 -> 1 -> 2 -> 3 -> 4 -> 4
14	Extract min	[5(L1),6(L3)]	5(L1)	[6(L3)]	1 -> 1 -> 2 -> 3 -> 4 -> 4 -> 5
15	Insert next of extracted	[6(L3)]	None	[6(L3)]	1 -> 1 -> 2 -> 3 -> 4 -> 4 -> 5
16	Extract min	[6(L3)]	6(L3)	[]	1 -> 1 -> 2 -> 3 -> 4 -> 4 -> 5 -> 6
17	Insert next of extracted	[]	None	[]	1 -> 1 -> 2 -> 3 -> 4 -> 4 -> 5 -> 6
18	Heap empty	[]	None	[]	Merged list complete

💡 Heap is empty, all nodes merged into one sorted list

Variable Tracker

Variable	Start	After Step 1	After Step 5	After Step 10	After Step 15	Final
minHeap	[]	[1(L1),1(L2),2(L3)]	[2(L3),3(L2),4(L1)]	[4(L2),6(L3)]	[6(L3)]	[]
mergedList	Empty	Empty	1 -> 1	1 -> 1 -> 2 -> 3 -> 4	1 -> 1 -> 2 -> 3 -> 4 -> 4 -> 5	1 -> 1 -> 2 -> 3 -> 4 -> 4 -> 5 -> 6

Key Moments - 3 Insights

Why do we insert only the first node of each list into the heap initially?

Because the lists are sorted, the first node is the smallest in each list. We start with these to find the overall smallest node among all lists, as shown in execution_table step 1.

Why do we insert the next node of the extracted node into the heap?

After extracting the smallest node, the next node in that list might be the next smallest candidate. Inserting it keeps the heap updated with current smallest nodes, as seen in steps 3, 5, 7, etc.

How do we know when to stop the merging process?

When the heap becomes empty, it means all nodes from all lists have been extracted and merged. This is shown in execution_table step 18.

Visual Quiz - 3 Questions

Look at the execution_table at step 4, which node was extracted from the heap?

A 1 from list 1

B 1 from list 2

C 2 from list 3

D 4 from list 1

💡 Hint

Check the 'Extracted Node' column at step 4 in execution_table

At which step does the merged list first contain the node with value 3?

A Step 6

B Step 10

C Step 8

D Step 12

💡 Hint

Look at the 'Merged List State' column and find when '3' appears

If we did not insert the next node after extraction, what would happen to the heap size over time?

A Heap size would shrink and eventually become empty too soon

B Heap size would stay constant

C Heap size would grow indefinitely

D Heap size would alternate between 1 and 2

💡 Hint

Refer to variable_tracker for minHeap size changes after insertions

Concept Snapshot

Merge K Sorted Lists Using Min Heap:
- Insert first node of each list into min heap
- Extract min node from heap, add to merged list
- Insert next node of extracted node into heap if exists
- Repeat until heap empty
- Result is one merged sorted list

Full Transcript

To merge K sorted lists, we use a min heap to always pick the smallest current node. We start by inserting the first node of each list into the heap. Then, we repeatedly extract the smallest node, add it to the merged list, and insert the next node from that node's list into the heap if it exists. This process continues until the heap is empty, meaning all nodes are merged. The execution table shows each step's heap state, extracted node, and merged list state. The variable tracker follows the heap and merged list changes. Key moments clarify why we insert only the first nodes initially, why we insert next nodes after extraction, and when the process stops. The visual quiz tests understanding of these steps. This method efficiently merges all lists into one sorted list.