def test_2(self):
l3_0 = ListNode(0)
l4_0 = ListNode(0)
sum_list_node_0 = add_two_numbers(l3_0, l4_0)
self.assertEqual(stringify_list(sum_list_node_0), '0')
def test_2(self):
l1 = ListNode(2)
l0 = ListNode(1)
l0.next = l1
new_l = remove_nth_from_end(l0, 2)
str_new_l = stringify_list(new_l)
self.assertEqual(str_new_l, '2')
def test_4(self):
l7_0 = ListNode(9)
l7_1 = ListNode(9)
l7_0.next = l7_1
l8_0 = ListNode(1)
sum_list_node_0 = add_two_numbers(l7_0, l8_0)
self.assertEqual(stringify_list(sum_list_node_0), '0 -> 0 -> 1')
def test_3(self):
k = [
ListNode(1),
ListNode(0)
]
expected = '0 -> 1'
merged = merge_k_lists(k)
self.assertEqual(stringify_list(merged), expected)
def test_2(self):
l1 = None
l2 = ListNode(0)
expected = '0'
merged = merge_two_lists(l1, l2)
self.assertEqual(stringify_list(merged), expected)
def test_1(self):
k = [
ListNode(1, ListNode(4, ListNode(5))),
ListNode(1, ListNode(3, ListNode(4))),
ListNode(2, ListNode(6))
]
expected = '1 -> 1 -> 2 -> 3 -> 4 -> 4 -> 5 -> 6'
merged = merge_k_lists(k)
self.assertEqual(stringify_list(merged), expected)
def add_two_numbers(l1: ListNode, l2: ListNode) -> ListNode:
og_sum_node = None
curr_sum_node = None
carry = False
while l1 or l2:
l1_val = l1.val if l1 else 0
l2_val = l2.val if l2 else 0
sum_val = None
if l1_val != None and l2_val != None:
summed = l1_val + l2_val
if carry:
summed += 1
if summed > 9:
carry = True
# last digit only
sum_val = summed % 10
else:
carry = False
sum_val = summed
if sum_val != None:
sum_node = ListNode(sum_val)
if curr_sum_node:
curr_sum_node.next = sum_node
curr_sum_node = sum_node
else:
og_sum_node = sum_node
curr_sum_node = sum_node
l1 = l1.next if l1 else None
l2 = l2.next if l2 else None
if carry:
curr_sum_node.next = ListNode(1)
return og_sum_node
def test_4(self):
k = [
ListNode(1, ListNode(2, ListNode(2))),
ListNode(1, ListNode(1, ListNode(2)))
]
expected = '1 -> 1 -> 1 -> 2 -> 2 -> 2'
merged = merge_k_lists(k)
self.assertEqual(stringify_list(merged), expected)
def merge_k_lists(lists: List[ListNode]) -> ListNode:
output = None
output_head = None
if len(lists) == 0:
return None
elif len(lists) == 1:
return lists[0]
heap = None
# Insert all ListNode values into our MinHeap
for node in lists:
while node:
v = node.val
if heap is None:
heap = MinHeap(v)
else:
heap.insert(v)
node = node.next
if heap is None:
return None
# Pop values off of the heap 1 by 1 to assemble merged list
popped = heap.pop()
while popped is not None:
if output is None:
output = ListNode(popped)
output_head = output
else:
output.next = ListNode(popped)
output = output.next
popped = heap.pop()
return output_head
def reverse(head: ListNode) -> ListNode:
if not head or not head.next:
return head
prev = head
head = head.next
prev.next = None
while head:
nxt = head.nxt
head.next = prev
prev = head
if nxt:
head = nxt
else:
break
return head
def test_1(self):
l4 = ListNode(5)
l3 = ListNode(4)
l3.next = l4
l2 = ListNode(3)
l2.next = l3
l1 = ListNode(2)
l1.next = l2
l0 = ListNode(1)
l0.next = l1
new_l = remove_nth_from_end(l0, 2)
str_new_l = stringify_list(new_l)
self.assertEqual(str_new_l, '1 -> 2 -> 3 -> 5')
def test_1(self):
l1_2 = ListNode(4)
l1_1 = ListNode(2)
l1_1.next = l1_2
l1_0 = ListNode(1)
l1_0.next = l1_1
l2_2 = ListNode(4)
l2_1 = ListNode(3)
l2_1.next = l2_2
l2_0 = ListNode(1)
l2_0.next = l2_1
expected = '1 -> 1 -> 2 -> 3 -> 4 -> 4'
merged = merge_two_lists(l1_0, l2_0)
self.assertEqual(stringify_list(merged), expected)
def test_3(self):
head = ListNode(1, ListNode(2, ListNode(3, ListNode(4, ListNode(5, ListNode(6))))))
head = swap_pairs(head)
s = stringify_list(head)
self.assertEqual(s, "2 -> 1 -> 4 -> 3 -> 6 -> 5")
def test_1(self):
# Build list 1
l1_2 = ListNode(3)
l1_1 = ListNode(4)
l1_1.next = l1_2
l1_0 = ListNode(2)
l1_0.next = l1_1
# Build list 2
l2_2 = ListNode(4)
l2_1 = ListNode(6)
l2_1.next = l2_2
l2_0 = ListNode(5)
l2_0.next = l2_1
sum_list_node_0 = add_two_numbers(l1_0, l2_0)
self.assertEqual(stringify_list(sum_list_node_0), '7 -> 0 -> 8')
def test_4(self):
head = ListNode(1, ListNode(2))
head = swap_pairs(head)
s = stringify_list(head)
self.assertEqual(s, "2 -> 1")
def test_3(self):
l5_0 = ListNode(5)
l6_0 = ListNode(5)
sum_list_node_0 = add_two_numbers(l5_0, l6_0)
self.assertEqual(stringify_list(sum_list_node_0), '0 -> 1')
def test_1(self):
head = ListNode(1, ListNode(2, ListNode(3, ListNode(4))))
head = swap_pairs(head)
s = stringify_list(head)
self.assertEqual(s, "2 -> 1 -> 4 -> 3")
def test_1(self):
l = ListNode(1, ListNode(1, ListNode(2)))
trimmed = delete_duplicates(l)
expected = '1 -> 2'
self.assertEqual(stringify_list(trimmed), expected)
def test_single(self):
l0 = ListNode(1)
new_l = remove_nth_from_end(l0, 1)
str_new_l = stringify_list(new_l)
self.assertEqual(str_new_l, '')
