[Python] Union[ListNode, None] vs. Optional[ListNode] vs. Optional['ListNode']

It seems we can use the following types for hinting LinkedLists in Python:

• Union[ListNode, None] or Union['ListNode', None]
• Optional[ListNode]
• Optional['ListNode']
• ...

Which of these should we prefer?

Feel free to share any other relevant insights as well.

Thank you!

Attempt


Here we simply want to merge K sorted LinkedLists:

from typing import Union, List, Any, Optional
import unittest
import gc


class ListNode:
def __init__(self, val: int = 0, next: Union['ListNode', None] = None):
self.val = val
self.next = next


class Solution:
def mergeKLists(self, linkedlists: Optional[List[ListNode]]) -> Union[ListNode, None]:
if not linkedlists:
return None
interval = 1
while interval < len(linkedlists):
for i in range(0, len(linkedlists) - interval, interval << 1):
linkedlists = self.merge_two_linkedlists(linkedlists, linkedlists[i + interval])
interval <<= 1

return linkedlists[0]

def merge_two_linkedlists(self, l1: Union[ListNode, None], l2: Union[ListNode, None]) -> Union[ListNode, None]:
sentinel = curr = ListNode()
while l1 and l2:
if l1.val <= l2.val:
curr.next = l1
l1 = l1.next
else:
curr.next = l2
l2 = l2.next
curr = curr.next

if l1:
curr.next = l1
else:
curr.next = l2

return sentinel.next


def main_test_merge_k_linkedlists(test_case_class):
suite = unittest.TestLoader().loadTestsFromTestCase(test_case_class)
runner = unittest.TextTestRunner(verbosity=2, failfast=1)
return runner.run(suite)


class TestMergeKLists(unittest.TestCase):
def test_merge_k_sorted_linkedlists(self):
l1 = ListNode(10)
l1.next = ListNode(20)
l2 = ListNode(40)
l2.next = ListNode(50)
l3 = ListNode(80)
l3.next = ListNode(150)
self.assertEqual(Solution().mergeKLists([l1, l2, l3]), l1)
l1 = l2 = l3 = None
gc.collect()


if __name__ == '__main__':
main_test_merge_k_linkedlists(TestMergeKLists)

Continue reading...