# LeetCode #23 : Merge k Sorted Lists

·1670 words·8 mins
coding leetcode python

## Description #

Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity.

Example:

Input:
[
1->4->5,
1->3->4,
2->6
]
Output: 1->1->2->3->4->4->5->6


(From the problem description)

### Test Vectors #

It is not said in the problem statement, but the implementation bases on the following assumptions

Ordering
All lists are ordered ascending and have comparable types.
Empty lists
Any list can be empty (None) but every node as a non-empty value.
nums solution Comment
[ [1,4,5], [1,3,4], [2,6] ] [1,1,2,3,4,4,5,6]
[] [] $$k = 0$$ is valid
[ ] 
[ [], [] ] [] all empty lists is a valid input
[ , …,  ] [1..100]

## Solutions #

### Problem API #

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None
class Solution:
def mergeKLists(self, lists: List[ListNode]) -> ListNode:


For debugging purposes it would be nice to print the whole list, so the ListNode class gets a minor upgrade:

from typing import List
class ListNode:

__slots__ = ['val', 'next']

def __init__(self, x):
self.val = x
self.next = None

def __str__(self):
if self.next:
return f"{self.val}->{self.next}"
else:
return f"{self.val}->END"

def __repr__(self):
return self.__str__()

def has_next(self):
return self.next is not None

def has_value(self):
return self.val is not None

# --- helper methods for testing ---
def to_node(digits) -> ListNode:
if not digits: return None
# copy that .. we will change it
digits = list(digits)
while digits:
n.next = ListNode(digits.pop(0))
n = n.next

def to_nodes(lists) -> List[ListNode]:
return [ to_node(sl) for sl in list(lists) ]

def from_node(head : ListNode) -> List:
r = []
return r


### Tests #

The test vectors are implemented by the following tests:

import os
import pytest

from typing import List

from supplemental import ListNode
from supplemental import to_node, to_nodes, from_node

class BaseTestClass:
def test_test_vector_from_problem_ok(self):
lists = to_nodes([[1,4,5], [1,3,4], [2,6]])

ret = self.mergeKLists(lists)

assert [1,1,2,3,4,4,5,6] == from_node(ret)

def test_k_equals_0_ok(self):
assert [] == from_node(self.mergeKLists([]))

def test_k_equals_1_ok(self):
assert  == from_node(self.mergeKLists(to_nodes([])))

def test_empty_lists_ok(self):
assert [] == from_node(self.mergeKLists(to_nodes([[], []])))


import os
import pytest

from typing import List

from supplemental import ListNode
from supplemental import to_node, to_nodes, from_node

class BaseBenchmarkClass:

def test_large_k_ok(self, benchmark):
LARGE_NUM=10_000
nodes = to_nodes([ [x] for x in reversed(range(0,LARGE_NUM))  ])

assert list(range(0,LARGE_NUM)) == from_node(benchmark(self.mergeKLists, lists=nodes))

def test_large_k_and_n_ok(self, benchmark):
LARGE_NUM=500

sublist = lambda seed : [ x * seed for x in range(0, LARGE_NUM)]
matrix = [ sublist(x) for x in range(0,LARGE_NUM)]

matrix_nodes = to_nodes(matrix)

count = 0
count += 1
assert LARGE_NUM * LARGE_NUM == count


It would be bad if the test tooling has bugs, so these are also tested:

from supplemental import ListNode
from supplemental import to_node, to_nodes, from_node

def test_to_node():
""" Make sure that the test tooling works. """

def test_from_node():
""" Make sure that the test tooling works. """
n = ListNode(1)
assert  == from_node(n)
n.next = ListNode(2)
assert [1,2] == from_node(n)

def test_transformer():
""" Make sure that the test tooling works. """
for test_value in [ , [1,2], [1,2,3] ]:

def test_to_nodes():
""" Make sure that the test tooling works. """
two_nodes = to_nodes([[1,2], [3,4]])
assert 2 == len(two_nodes)
assert 1 == two_nodes.val
assert 2 == two_nodes.next.val

assert 3 == two_nodes.val
assert 4 == two_nodes.next.val

============================= test session starts ==============================
platform linux -- Python 3.7.5, pytest-3.10.1, py-1.8.0, pluggy-0.12.0
benchmark: 3.2.2 (defaults: timer=time.perf_counter disable_gc=False min_rounds=5 min_time=0.000005 max_time=1.0 calibration_precision=10 warmup=False warmup_iterations=100000)
rootdir: /home/jens/Documents/leetcode.com/023-merge-k-sorted-lists, inifile:
plugins: benchmark-3.2.2, profiling-1.7.0
collected 4 items

test_supplemental.py ....                                                [100%]

============================ slowest test durations ============================

(0.00 durations hidden.  Use -vv to show these durations.)
=========================== 4 passed in 0.02 seconds ===========================

Tests ran in 0.16634120400703978 seconds


### Solution 1: Nested Loops $$O( k * n_{max})$$ #

This is a very straight forward solution.

Since all lists are guaranteed to be ordered the implementation looks at each of the $$k$$ lists to find the smallest element and appends it to the result. It does so until all lists are empty, at most $$n_{max}$$ times.

from typing import List
from supplemental import ListNode

class Solution:
"""
This is a very simple solution to the problem. In more complex environments (applications)
this implementation has some drawbacks because all passed in data is modified.

This could be solved by creating a copy of 'lists'. But leetcode has runtime constraints.
"""
def mergeKLists(self, lists: List[ListNode]) -> ListNode:
tail = None

# Done := the last element of the longest list has been processed -> no more elmenents
# to process
done = False
while not done:
# Python int is unbounded, so the MAX_INT trick does not work
# Also: It should work on non integers
lowest_list_value = None
lowest_list_idx = None

for n in range(0, len(lists)):
l = lists[n]
# an empty list (EOFed) is None
if l and not l.val is None:
if lowest_list_value is None or l.val < lowest_list_value:
lowest_list_value = l.val
lowest_list_idx = n

# IF no element has been found then
# all lists are empty and we are done
done = lowest_list_idx is None

if not done:
# The lowest value has been found.
# store it
else:
tail.next = ListNode(lowest_list_value)
tail = tail.next

# the list where the lowest element has been found
# 'eat' the found element
lists[lowest_list_idx] = lists[lowest_list_idx].next



#### Test Results #

With the following test result:

============================= test session starts ==============================
platform linux -- Python 3.7.5, pytest-3.10.1, py-1.8.0, pluggy-0.12.0
benchmark: 3.2.2 (defaults: timer=time.perf_counter disable_gc=False min_rounds=5 min_time=0.000005 max_time=1.0 calibration_precision=10 warmup=False warmup_iterations=100000)
rootdir: /home/jens/Documents/leetcode.com/023-merge-k-sorted-lists, inifile:
plugins: benchmark-3.2.2, profiling-1.7.0
collected 4 items

test_1a-solution.py ....                                                 [100%]

============================ slowest test durations ============================

(0.00 durations hidden.  Use -vv to show these durations.)
=========================== 4 passed in 0.04 seconds ===========================

Tests ran in 0.18874403899826575 seconds


Benchmark:

#### Analysis #

Since all lists are guaranteed to be ordered the implementation looks at each of the $$k$$ lists to find the smallest element and appends it to the result. It does so until all lists are empty, at most $$n_{max}$$ times.

• Let $$k$$ be the number of items passed in the lists parameter.
• Let $$n_{max}$$ be the longest list from lists
• Let the total number of all elements be constant for Best/Avg/Worst case calculation.

The analysis follows the algorithms structure:

Best Case
The best case runtime is linear for $$k=1$$ or $$n=1$$: $$\Omega(max(k, n_{max}))$$. To be more precise: The theoretic lower bound for this task is $$\Omega(e)$$ where $$e$$ is the number of elements in lists.
Average Case
The overall runtime is quadratic, as can be seen from the description of the algorithm (two nested loops): $$O(k*n_{max})$$.
Worst Case
The worst case behavior shows itself when the outer ($$k$$) and inner ($$n$$) loops have the same length (the maximum of $$n*k$$ with $$n+k$$ is at $$n=k$$). This is still $$O(n*k)$$.
Edge Cases
These edge cases can be considered as well:
• $$k=0$$ is trivial ($$O(1)$$).
• $$n_{max}=0$$ is also trivial ($$O(k)$$).

### Solution 2: Heap based $$O(n * log k)$$ #

The first solution was not fast enough. But maybe there are some optimizations left?

Code optimizations
In python iterating over lists is expensive. Pushing some tasks into C code can substantially speed up the code. But this should be done last.
Algorithmic optimizations
The algorithm in the first solution is not to ideal when $$k \approx n$$ because of the quadratic runtime. The expensive part is finding the next smallest element, which always is done $$n$$ times. Reducing $$n$$ to e.g. $$log n$$ is not possible because the data structure forces a sequential walk through the lists with $$O(n)$$. But finding the next smallest element can be improved. The first solution takes $$O(k)$$. This can be improved to $$O(log k)$$ by using e.g. a heap.

from typing import List
from supplemental import ListNode
import heapq

class Solution:
"""
This solution uses a heap to find the next smallest element.
"""
def mergeKLists(self, lists: List[ListNode]) -> ListNode:
tail = None

# we do not want to modify lists.

# Heap of tupels (val, index into hedas to the NodeList where val came from).
# val is needed so that the elements can be sorted
# NodeList (i) is needed so we can advance
heap = []
if l and l.val is not None:
heapq.heappush(heap, (l.val, i))
found_item = True

# Done := all elements have been added to the heap
while len(heap) > 0:
val,index = heapq.heappop(heap)

# advance the list of the found node.
if next_node and next_node.val is not None:
heapq.heappush(heap, (next_node.val, index))

else:
tail.next = ListNode(val)
tail = tail.next



#### Test Results #

With the following test result:

============================= test session starts ==============================
platform linux -- Python 3.7.5, pytest-3.10.1, py-1.8.0, pluggy-0.12.0
benchmark: 3.2.2 (defaults: timer=time.perf_counter disable_gc=False min_rounds=5 min_time=0.000005 max_time=1.0 calibration_precision=10 warmup=False warmup_iterations=100000)
rootdir: /home/jens/Documents/leetcode.com/023-merge-k-sorted-lists, inifile:
plugins: benchmark-3.2.2, profiling-1.7.0
collected 4 items

test_2a-solution.py ....                                                 [100%]

============================ slowest test durations ============================

(0.00 durations hidden.  Use -vv to show these durations.)
=========================== 4 passed in 0.02 seconds ===========================

Tests ran in 0.1691520269960165 seconds


Benchmark:

#### Analysis #

Average Case
The overall runtime is $$O(n_{max} * log(k))$$. The improvement is replacing the $$O(k)$$ lookup with a heap based $$O(log(k))$$ lookup.

A lot of the performance improvements stem from pushing computation into C code. The boost seen in the tests is not explainable by the algorithm itself (esp. the $$k=1$$ case).

## Summary #

All solutions work (except #1 which leads to a timeout for large data sets).

Solution Correct Status Runtime Memory Language
#1, $$O(n*k)$$ No Submission Time Limit Exceeded Time Limit Exceeded Python3
#2, $$O(n*log k)$$ Yes Submission 104 ms, faster than 83.12% 16.6 MB, less than 42.42% Python3