Merge K Sorted Lists

You are given k singly linked lists, each sorted in nondecreasing order. For the runner, lists[i] stores the node values of the i-th list from head to tail.
Merge all lists into one sorted linked list and return its values from head to tail. Reusing existing nodes or constructing an equivalent merged list are both acceptable.

Function
mergeKSortedLists(lists: int[][]) → int[]

Examples
Example 1
lists = [[1,4,5],[1,3,4],[2,6]]
return = [1,1,2,3,4,4,5,6]
Taking the smallest available head at each step produces the complete nondecreasing merge.
Example 2
lists = []
return = []
With no input lists, the merged list is empty.
Example 3
lists = [[],[-2,0,7],[]]
return = [-2,0,7]
Empty lists contribute no nodes, so the one nonempty list is returned unchanged in value order.

Constraints
0 <= lists.length <= 10000.
0 <= lists[i].length <= 500.
The total number of values across all lists is at most 100000.
-10^9 <= lists[i][j] <= 10^9.
Every lists[i] is sorted in nondecreasing order.

The trick is a min-heap holding one entry per list: the current value, the list index, and the position in that list. Pop the smallest, append it to the output, then push the next element from that same list if one exists. Each of the N total values gets pushed and popped once, so you get O(N log k). Pitfalls: skipping empty lists when seeding the heap, and forgetting that lists can be empty entirely (the lists = [] case returns []). Don't push all values and sort. That's O(N log N) and it works, but it misses the point. Also watch your tuple comparison so ties don't break on something unorderable. An alternative is pairwise divide and conquer merging, which hits the same complexity. If the heap code slips away mid-assessment, StealthCoder is the hedge that gives you a working solution on screen without the proctor seeing anything.

The honest play: practice the pattern, and have StealthCoder ready for the one you didn't see coming.