def test_merge_two_sorted_lists(self):
head = merge_k_lists(
[generate_linked_list([1, 4, 5]).get_head(),
generate_linked_list([1, 3, 4]).get_head(),
generate_linked_list([2, 6]).get_head()])
result = LinkedList(head=head)
self.assertListEqual([1, 1, 2, 3, 4, 4, 5, 6], result.to_list())
def test_partition_list(self):
linked_list_1 = generate_linked_list([2, 4, 3])
linked_list_2 = generate_linked_list([5, 6, 4])
head = add_two_numbers(linked_list_1.get_head(),
linked_list_2.get_head())
linked_list_3 = LinkedList(singly=True, head=head)
self.assertListEqual([7, 0, 8], linked_list_3.to_list())
def assert_operation(val_list, pos=-1):
linked_list = generate_linked_list(val_list)
if pos >= 0:
linked_list.at(len(val_list) - 1).next = linked_list.at(pos)
self.assertTrue(has_cycle(linked_list.get_head()))
else:
self.assertFalse(has_cycle(linked_list.get_head()))
def assert_operation(val_list, pos=-1):
linked_list = generate_linked_list(val_list)
if pos >= 0:
linked_list.at(len(val_list) - 1).next = linked_list.at(pos)
self.assertEqual(linked_list.at(pos),
detect_cycle(linked_list.get_head()))
else:
self.assertEqual(None, detect_cycle(linked_list.get_head()))
def test_remove_nth_from_end_of_list(self):
linked_list = generate_linked_list([1, 2, 3, 4, 5])
head = remove_nth_from_end(linked_list.get_head(), 2)
linked_list.set_head(head)
self.assertListEqual([1, 2, 3, 5], linked_list.to_list())
head = remove_nth_from_end(linked_list.get_head(), 1)
linked_list.set_head(head)
self.assertListEqual([1, 2, 3], linked_list.to_list())
head = remove_nth_from_end(linked_list.get_head(), 3)
linked_list.set_head(head)
self.assertListEqual([2, 3], linked_list.to_list())
def assert_operation(in_list, val, out_list):
linked_list = generate_linked_list(in_list)
head = remove_elements(linked_list.get_head(), val)
linked_list.set_head(head)
self.assertListEqual(out_list, linked_list.to_list())
def assert_operation(in_list, out_list):
linked_list = generate_linked_list(in_list)
reorder_list(linked_list.get_head())
self.assertListEqual(out_list, linked_list.to_list())
def test_reverse_linked_list_ii(self):
linked_list = generate_linked_list([1, 2, 3, 4, 5])
head = reverse_between(linked_list.get_head(), 2, 4)
linked_list.set_head(head)
self.assertListEqual([1, 4, 3, 2, 5], linked_list.to_list())
def assert_operation(in_list, k, out_list):
linked_list = generate_linked_list(in_list)
head = rotate_right(linked_list.get_head(), k)
linked_list.set_head(head)
self.assertListEqual(out_list, linked_list.to_list())
def test_merge_two_sorted_lists(self):
l1 = generate_linked_list([1, 2, 4])
l2 = generate_linked_list([1, 3, 4])
head = merge_two_lists(l1.get_head(), l2.get_head())
l3 = LinkedList(head=head)
self.assertListEqual([1, 1, 2, 3, 4, 4], l3.to_list())
def assert_operation(in_list, result):
linked_list = generate_linked_list(in_list)
if result:
self.assertTrue(is_palindrome(linked_list.get_head()))
else:
self.assertFalse(is_palindrome(linked_list.get_head()))
def assert_operation(in_list, out_list):
linked_list = generate_linked_list(in_list)
head = insertion_sort_list(linked_list.get_head())
linked_list.set_head(head)
self.assertListEqual(out_list, linked_list.to_list())
def test_reverse_linked_list_recursive(self):
linked_list = generate_linked_list([1, 2, 3, 4, 5])
head = reverse_list_recursive(linked_list.get_head())
linked_list.set_head(head)
self.assertListEqual([5, 4, 3, 2, 1], linked_list.to_list())
