# end of binary tree
            return False
        # Current level match up and next node match up with either child node
        return probe_head.val == probe_root.val and \
               (downward_probe(probe_head.next, probe_root.left) or downward_probe(probe_head.next, probe_root.right))

    if not root:
        # Empty tree
        return False
    # Start downward path from probe_root
    # or wait until child node to start downward path
    return downward_probe(head, root) or is_sub_path(
        head, root.left) or is_sub_path(head, root.right)


test_cases = [
    ([4, 2, 8],
     [1, 4, 4, None, 2, 2, None, 1, None, 6, 8, None, None, None, None, 1,
      3], True),
    ([1, 4, 2, 6],
     [1, 4, 4, None, 2, 2, None, 1, None, 6, 8, None, None, None, None, 1,
      3], True),
    ([1, 4, 2, 6, 8],
     [1, 4, 4, None, 2, 2, None, 1, None, 6, 8, None, None, None, None, 1,
      3], False)
]
for build_list, build_tree, expected_output in test_cases:
    assert is_sub_path(
        LinkedList.create_linked_list(build_list).head,
        ConstructTree.build_tree_leetcode(build_tree).root) is expected_output
    fast_pointer = slow_pointer = head
    prev_pointer = None
    while fast_pointer and fast_pointer.next:
        fast_pointer = fast_pointer.next.next
        tmp_pointer = slow_pointer.next
        slow_pointer.next = prev_pointer
        prev_pointer = slow_pointer
        slow_pointer = tmp_pointer

    if fast_pointer:
        # odd length case
        slow_pointer = slow_pointer.next

    while slow_pointer:
        if slow_pointer.val != prev_pointer.val:
            return False
        slow_pointer = slow_pointer.next
        prev_pointer = prev_pointer.next

    return True


test_cases = [([1, 2, 2, 1], True),
              ([1, 2], False),
              ([1, 2, 3, 4, 5, 4, 3, 2, 1], True),
              ([1, 2, 3, 4, 4, 3, 2, 1], True),
              ([1, 2, 3, 4, 5, 4, 2, 1], False),
              ([1, 2, 3, 4, 5, 6, 3, 2, 1], False), ]
for test_list, expected_output in test_cases:
    assert is_palindrome(head=LinkedList.create_linked_list(test_list).head) is expected_output
Exemple #3
0
    elif carry_over:
        current_node.next = ListNode(carry_over)

    return dummy_node.next


test_cases = [
    ([2, 4, 3], [5, 6, 4], [7, 0, 8]),
    ([0], [0], [0]),
    ([1, 8], [0], [1, 8]),
    ([9, 9, 9, 9, 9, 9, 9], [9, 9, 9, 9], [8, 9, 9, 9, 0, 0, 0, 1]),
    ([
        2, 4, 3, 2, 4, 3, 2, 4, 3, 2, 4, 3, 2, 4, 3, 2, 4, 3, 2, 4, 3, 2, 4, 3,
        2, 4, 3, 2, 4, 3, 2, 4, 3, 2, 4, 3, 2, 4, 3, 2, 4, 3, 2, 4, 3, 2, 4, 3,
        2, 4, 3, 2, 4, 3, 2, 4, 3, 2, 4, 3, 9
    ], [
        5, 6, 4, 2, 4, 3, 2, 4, 3, 2, 4, 3, 2, 4, 3, 2, 4, 3, 2, 4, 3, 2, 4, 3,
        2, 4, 3, 2, 4, 3, 2, 4, 3, 2, 4, 3, 2, 4, 3, 2, 4, 3, 2, 4, 3, 2, 4, 3,
        2, 4, 3, 2, 4, 3, 2, 4, 3, 9, 9, 9, 9
    ], [
        7, 0, 8, 4, 8, 6, 4, 8, 6, 4, 8, 6, 4, 8, 6, 4, 8, 6, 4, 8, 6, 4, 8, 6,
        4, 8, 6, 4, 8, 6, 4, 8, 6, 4, 8, 6, 4, 8, 6, 4, 8, 6, 4, 8, 6, 4, 8, 6,
        4, 8, 6, 4, 8, 6, 4, 8, 6, 1, 4, 3, 9, 1
    ]),
]
for input_1, input_2, expected_output in test_cases:
    assert add_two_number(
        l1=LinkedList.create_linked_list(input_1).head,
        l2=LinkedList.create_linked_list(
            input_2).head).list_from_node() == expected_output
assert not new_bst.look_up(14)

for i in range(len(values)):
    deletion_tree = deepcopy(new_bst)
    assert deletion_tree.delete_node(values[i])
    assert deletion_tree.is_valid()
    # print('Deleted: %d, Remaining: %s' % (values[i], str(deletion_tree.traversal())))
    assert deletion_tree.traversal() == values[:i] + values[i + 1:]

expected_values = [6, 7, 8, 9, 10, 11, 12, 13]
assert new_bst.traverse_range(6, 13) == expected_values
assert new_bst.traverse_range(6, 14) == expected_values
assert new_bst.traverse_range(5.5, 13) == expected_values

sorted_list = list(range(1, 11))
head = LinkedList.create_linked_list(sorted_list)
new_bst = BST(head)
assert new_bst.traversal() == sorted_list
assert new_bst.is_balanced()

new_bst = BST([-1])
new_bst.root.right = TreeNode(1)
new_bst.root.right.left = TreeNode(-1)
assert new_bst.is_valid()

new_bst = BST([1])
new_bst.root.left = TreeNode(-1)
new_bst.root.left.right = TreeNode(1)
assert not new_bst.is_valid()

new_bst = BST([1, 3, 4])
    ]),
    (list(range(9)), [
        0,
        8,
        1,
        7,
        2,
        6,
        3,
        5,
        4,
    ]),
    ([
        1,
    ], [
        1,
    ]),
    ([
        1,
        2,
    ], [
        1,
        2,
    ]),
]
for test_input, test_output in test_cases:
    test_head = LinkedList.create_linked_list(test_input).head
    assert test_head.list_from_node() == test_input
    reorder_list(head=test_head)
    assert test_head.list_from_node() == test_output
Exemple #6
0
    :param head: head of a linked list, can be None
    :param val: remove all elements from linked list that equals to val
    :return: head of the remaining linked list, return None if nothing left
    """
    while head and head.val == val:
        head = head.next
    if head is None:
        return None
    current_node = head
    while current_node.next:
        if current_node.next.val == val:
            current_node.next = current_node.next.next
        else:
            current_node = current_node.next
    return head


N, l = 1000, 300
a, b = -100, 100
for i in range(N):
    test_target = randint(a, b)
    test_input_list = [test_target] + [randint(a, b) for _ in range(l)]
    test_output_list = list(filter(lambda x: x != test_target,
                                   test_input_list))
    get_output = remove_elements(
        LinkedList.create_linked_list(test_input_list).head, test_target)
    assert get_output.list_from_node() == test_output_list
assert remove_elements(
    LinkedList.create_linked_list([1] * randint(10, 50)).head, 1) is None
assert remove_elements(None, 1) is None
Exemple #7
0
    """
    dummy_node = probe_node = proceeding_node = ListNode(0, next=head)
    for _ in range(n):
        # 1 <= n <= length of list guaranteed; does not need to check for boundary condition
        probe_node = probe_node.next

    while probe_node.next:
        probe_node = probe_node.next
        proceeding_node = proceeding_node.next

    proceeding_node.next = proceeding_node.next.next
    return dummy_node.next


test_cases = [
    ([1, 2, 3, 4, 5], 1, [1, 2, 3, 4]),
    ([1, 2, 3, 4, 5], 2, [1, 2, 3, 5]),
    ([1, 2, 3, 4, 5], 5, [2, 3, 4, 5]),
    ([1], 1, []),
    ([1, 2], 1, [1]),
    ([5, 6, 9, 8, 6, 4, 5, 1, 9, 8, 7, 2, 8, 6, 8, 3, 5, 8,
      6], 17, [5, 6, 8, 6, 4, 5, 1, 9, 8, 7, 2, 8, 6, 8, 3, 5, 8, 6]),
]
for test_list, test_n, expected_output in test_cases:
    return_head = remove_nth_node(
        LinkedList.create_linked_list(test_list).head, test_n)
    if expected_output:
        assert return_head.list_from_node() == expected_output
    else:
        assert return_head is None
Exemple #8
0
test_cases = [
    ([1, 2, 3, 4, 5, 6], 2, 5),
    ([1, 2, 3, 4, 5], 2, 4),
    ([5], 1, 1),
    ([-5, 4, -2, -2, -2, 3, -3], 6, 6),
    ([
        -18, -29, 30, 10, -45, -93, 9, -4, -52, 91, 61, 91, 19, 32, -100, 34,
        38, 99, -93, -37, 73, -67, -29, 52, 6, -50, -87, -33, 6, -72, 72, 89,
        -51, -48, -52, -45, -41, 7, 1, -42, -3, -38, -52, 66, 44, 99, 0, -19,
        47, 7, 44, 19, -10, 65, -30, 96, -86, -17, -87, -29, -39, 85, -41, -39,
        87, -43, -34, -54, 65, 67, 4, -39, 79, 2, -73, 23, 0, -23, 54, 97, 34,
        -2, -35, -77, -88, -14, 69, 78, 19, 82, -52, 81, 17, -43, 92, 3, 14,
        -43, 49, -22, 74, -98, -10, 53, 4, -33, -75, 54, 44, 79, 50, -73, -74,
        66, -50, -61, -49, -82, -84, 70, -100, -86, 0, 17, -29, -59, 70, 85,
        -2, 19, -87, -78, -29, -47, 75, 26, -30, 100, -21, 64, 28, 80, 91, 55,
        45, -60, 94, 46, -42, 60, 15, -92, 74, -85, -25, -56, -44, -55, 79, 5,
        14, 42, -23, 35, 95, -49, -40, -86, -100, -10, 78, 28, -31, 68, -18,
        64, -93, -75, -41, -84, 85, 74, 75, 8, 39, -100, 2, 46, 96, -69, -100,
        -41, 73, -23, 94, 18, -22, -46, 32, -22, 44, 10, 56, 63, -23, 89, -24,
        -65, -87, 35, -99, 49, 8, 76, -44, 98, 26, 9, 43, 21, 40, -7, 80, 12,
        70, 74, 80, -53, -73, 12, -25, 21, 72, -70, -17, -52, -82, 59, -67, 83,
        -7, -66, 31, 51, 61, 37, 48, -14, -55, -60, 58, 85, 33, 37, -53, -48,
        -40, -74, -51, -63, -12, 24, 58, -41, 5, 91, -42, -27, 49, -9, -95, 92,
        -24, 36, -7, 87, -77, 91, -78, -82, 82, 80, 54, -36, -33, -100, 17, 27,
        77, 16, 65, -35, -60, -28, 24, -5, -37, 82, 18, 62, -77, 24, 4, -1, -41
    ], 209, 286),
]
for test_list, test_left, test_right in test_cases:
    assert reverse_between(LinkedList.create_linked_list(test_list).head, test_left, test_right).list_from_node() == \
           test_list[:test_left - 1] + list(reversed(test_list[test_left - 1: test_right])) + test_list[test_right:]
Exemple #9
0
        if current_b.next:
            # traverse down the list
            current_b = current_b.next
        elif continue_b:
            # switch to list a to finish the remaining len_a steps
            current_b, continue_b = head_a, False
        else:
            # cap out at len_a + len_b + len_c steps
            # no need to traverse more
            return None

    return current_a


test_cases = [
    ([4, 1], [5, 6, 1], [8, 4, 5]),
    ([1, 9, 1], [3], [2, 4]),
    ([2, 6, 4], [1, 5], []),
    ([4, 1], [5, 6, 1], [8, 4, 5]),
    ([2, 6, 4], [2, 6, 4], []),
]
for list_a, list_b, list_c in test_cases:
    test_head_a = LinkedList.create_linked_list(list_a).head
    test_head_b = LinkedList.create_linked_list(list_b).head
    test_head_c = LinkedList.create_linked_list(list_c).head
    test_head_a.last_node().next = test_head_c
    test_head_b.last_node().next = test_head_c
    assert get_intersection_node(head_a=test_head_a,
                                 head_b=test_head_b) is test_head_c
Exemple #10
0
        current_node.next = l2

    return dummy_head.next


test_cases = [
    ([1, 2, 4], [1, 3, 4], [1, 1, 2, 3, 4, 4]),
    ([], [], []),
    ([], [0], [0]),
    ([
        -20, -19, -17, -17, -13, -5, -5, -4, -1, -1, 0, 1, 11, 16, 18, 19, 20,
        21, 21, 22, 22, 23, 25, 28, 29
    ], [
        -30, -27, -22, -21, -18, -17, -17, -13, -13, -5, -4, -1, 0, 6, 7, 8,
        10, 15, 25, 27
    ], [
        -30, -27, -22, -21, -20, -19, -18, -17, -17, -17, -17, -13, -13, -13,
        -5, -5, -5, -4, -4, -1, -1, -1, 0, 0, 1, 6, 7, 8, 10, 11, 15, 16, 18,
        19, 20, 21, 21, 22, 22, 23, 25, 25, 27, 28, 29
    ]),
]
for test_l1_list, test_l2_list, expected_output in test_cases:
    if expected_output:
        assert merge_two_sorted_lists(LinkedList.create_linked_list(test_l1_list).head,
                                      LinkedList.create_linked_list(test_l2_list).head).list_from_node() \
               == expected_output
    else:
        assert merge_two_sorted_lists(
            LinkedList.create_linked_list(test_l1_list).head,
            LinkedList.create_linked_list(test_l2_list).head) is None
Exemple #11
0
            greater_current.next = head
            greater_current = head
        head = head.next

    greater_current.next = None
    less_current.next = greater_dummy.next

    return less_dummy.next


test_cases = [
    ([1, 4, 3, 2, 5, 2], 3),
    ([2, 1], 2),
    ([
        -4, -4, -6, 8, 3, 7, -5, -8, 0, -3, -5, 5, -1, -3, -4, 3, 4, 0, -3, -6,
        9, 4, -7, -6, -8
    ], 9),
    ([
        -21, -59, 4, -99, 84, -65, -32, -80, 12, -45, 17, -52, 72, -51, -64,
        -37, -34, -28, 85, -3, -22, 1, 4, -2, 12, -70, -83, 48, -99, 31, -87,
        -19, 24, 18, -66, 8, 5, 2, -20, -83, 10, 49, -35, -66, 99, -46, -3,
        -83, -22, -65, 14, 8, -12, 71, -94, -100, -99, 75, 48, -98, -42, 62,
        -65, 82, -68, -78, -58, 37, -24, -26, 55, 86, -76, 72, -79, 75, -74,
        -30, 92, -43, 5, 7, 65, 93, -70, 24, 93, -69, -1, 42, 85, 58, -44, 73,
        -8, -12, 95, -13, 77, -29, 61, -16, -90, 37, -91
    ], 53),
]
for test_input, test_x in test_cases:
    assert partition(LinkedList.create_linked_list(test_input).head, test_x).list_from_node() == \
           [x_i for x_i in test_input if x_i < test_x] + [x_i for x_i in test_input if x_i >= test_x]
"""
from _Linked_List import ListNode, LinkedList


def reverse_list(head: ListNode) -> ListNode:
    """
    :param head: head of a singly linked list
    :return: the head of the reversed list
    """
    previous_node, current_node = None, head
    while current_node:
        next_node = current_node.next
        current_node.next = previous_node
        previous_node, current_node = current_node, next_node

    return previous_node


test_cases = [
    [1, 2, 3, 4, 5],
    [1, 2],
    [],
]
for test_input in test_cases:
    test_list = LinkedList.create_linked_list(test_input)
    test_list.head = reverse_list(head=test_list.head)
    if not test_input:
        assert test_list.head is None
    else:
        assert test_list.head.list_from_node() == test_input[::-1]
from random import randint

from _Linked_Complex import DoubleLinkedList, ComplexLinkedList
from _Linked_List import LinkedList, PrintableLinkedList, ListNode

test_node = ListNode(0)
assert test_node.last_node().val == 0
assert test_node.count_to_last() == 1

node_list = [1, 2, 3, 4, 5]
linked_list = LinkedList.create_linked_list(node_list)
assert node_list == linked_list.head.list_from_node()
assert linked_list.head.last_node().val == 5
assert len(linked_list) == len(node_list)
point_to = linked_list.head
expected_len = len(node_list)
while point_to:
    assert point_to.count_to_last() == expected_len
    point_to = point_to.next
    expected_len -= 1

assert LinkedList.create_linked_list([]).midpoint_of_list() == (0, None)
for list_len in range(1, 8):
    midpoint_index, midpoint = LinkedList.create_linked_list(
        list(range(1, list_len + 1))).midpoint_of_list()
    expected_index = list_len // 2
    assert midpoint_index == expected_index and midpoint.val == midpoint_index + 1

printable_list = PrintableLinkedList.create_linked_list(node_list)
separator = ', '
expected_output = separator.join([str(val) for val in node_list])
    while l1:
        n1 = n1 * 10 + l1.val
        l1 = l1.next
    while l2:
        n2 = n2 * 10 + l2.val
        l2 = l2.next

    n3 = n1 + n2
    return_head = None
    while n3 > 0:
        return_head = ListNode(n3 % 10, next=return_head)
        n3 //= 10

    return return_head if return_head else ListNode(0)


test_cases = [
    ([7, 2, 4, 3], [5, 6, 4], [7, 8, 0, 7]),
    ([2, 4, 3], [5, 6, 4], [8, 0, 7]),
    ([0], [0], [0]),
    ([9, 9, 3], [1], [9, 9, 4]),
    ([9, 9, 3], [7], [1, 0, 0, 0]),
    ([5, 5, 5], [4, 9, 5], [1, 0, 5, 0]),
]
for add_two_numbers in [add_two_numbers_stack, add_two_numbers_int]:
    for test_l1_list, test_l2_list, expected_output in test_cases:
        assert add_two_numbers(
            LinkedList.create_linked_list(test_l1_list).head,
            LinkedList.create_linked_list(
                test_l2_list).head).list_from_node() == expected_output