def test_two_items():
    head = Node(1, next=Node(2))
    expected = Node(2, next=Node(1))
    actual = reverse_linked_list(head)

    assert actual == expected
    assert has_cycle(actual) is True
def test_example():
    root = Node(2, left=Node(1), right=Node(3))
    node1 = Node(1)
    node2 = Node(3)
    expected = 2

    assert recursive_solution(root, node1, node2) == expected
def clone_graph(node):
    if not node:
        return None

    node_map = dict()
    queue = []

    queue.append(node)
    node_map[node] = Node(node.data, neighbors=[])

    while queue:
        current_node = queue.pop(0)

        for neighbor in current_node.neighbors:
            if neighbor not in node_map:
                # add it to the map
                node_map.update({neighbor: Node(neighbor.data, neighbors=[])})

                # add the neighbor to queue
                queue.append(neighbor)

            # update the cloned graph
            clone_of_current_node = node_map.get(current_node)
            clone_of_current_node.neighbors.append(node_map.get(neighbor))

    return node_map.get(node)
def test_non_valid_bst():
    node3 = Node(3)
    node6 = Node(6)
    node4 = Node(4, left=node3, right=node6)
    root = Node(5, left=Node(1), right=node4)

    assert is_valid_bst(root) is False
def test_negative_nums():
    nodeneg1 = Node(-1)
    node4 = Node(4)
    node2 = Node(2, left=nodeneg1, right=node4)
    node3 = Node(3)
    root = Node(-5, left=node2, right=node3)

    assert find_max_sum_binary_tree(root) == 6
def test_basic_case():
    node2leaf = Node(2)
    node3leaf = Node(3)
    node2 = Node(2, left=node2leaf, right=node3leaf)
    node4 = Node(4)
    root = Node(1, left=node2, right=node4)

    assert find_max_sum_binary_tree(root) == 10
Example #7
0
def build_complete_binary_tree(arr, root, index, node_count):
    if index < node_count:
        root = Node(arr[index])

        root.left = build_complete_binary_tree(arr, root.left, 2 * index + 1,
                                               node_count)
        root.right = build_complete_binary_tree(arr, root.right, 2 * index + 2,
                                                node_count)

    return root
Example #8
0
def iterative_solution(head):
    temp = Node(-11)
    temp.next = head
    visited = set()

    while temp:
        if temp.next in visited:
            return True

        visited.add(temp.next)
        temp = temp.next

    return False
Example #9
0
def test_balanced_binary_tree():
    """
    a balanced binary tree is a tree in which the left and right subtrees of every node differ in height by no more than 1

        1
       / \
      2   5
           \
             6
    """
    node5 = Node(5, right=Node(6))
    root = Node(1, left=Node(2), right=node5)

    assert inorder_traversal(root) == [2, 1, 5, 6]
Example #10
0
def test_degenerate_binary_tree():
    """
    a binary tree in which each parent node only has one child, essentially behaving like a linked list
        1
         \
          2
         /
        3
    """
    node3 = Node(3)
    node2 = Node(2, left=node3)
    root = Node(1, right=node2)

    assert inorder_traversal(root) == [1, 3, 2]
Example #11
0
def test_simple_case_should_be_true():
    root = Node(3)
    root_left = Node(9)
    root_right = Node(20, left=Node(15), right=Node(7))
    root.left = root_left
    root.right = root_right

    assert is_balanced(root) is True
Example #12
0
def iterative_solution(lists):
    """
    Merge two sorted linked lists and return it as a new list. The new list should be made by splicing together the nodes of the first two lists.

    Example:

    Input: 1->2->4, 1->3->4
    Output: 1->1->2->3->4->4

    """
    pre_root = Node(-1)
    current = pre_root

    while list1 and list2:
        if list1.data <= list2.data:
            current.next = list1
            list1 = list1.next
        else:
            current.next = list2
            list2 = list2.next
        current = current.next

    if not list1:
        current.next = list2
    else:
        current.next = list1

    return pre_root.next
def test_example():
    head = Node(1)
    temp = head
    for i in range(2, 6):
        temp.next = Node(i)
        temp = temp.next

    expected = Node(5)
    new_temp = expected
    for i in range(4, 0, -1):
        new_temp.next = Node(i)
        new_temp = new_temp.next

    actual = reverse_linked_list(head)

    assert actual == expected
    assert has_cycle(actual) is True
def test_ancestor_on_right():
    root = Node(2, left=Node(0), right=Node(4, left=Node(3), right=Node(5)))
    node1 = Node(0)
    node2 = Node(2)
    expected = 2

    assert recursive_solution(root, node1, node2) == expected
Example #15
0
def two_pointers_solution(head, n):
    ans = Node(-1, next=head)
    left = ans
    right = ans

    for _ in range(n + 1):
        right = right.next

    while right:
        right = right.next
        left = left.next

    left.next = left.next.next

    return ans.next
Example #16
0
def get_length_then_remove_nth_node(head, n):
    length = 0
    ans = Node(-1, next=head)
    temp = ans
    while temp:
        length += 1
        temp = temp.next

    steps_to_nth_plus_one_node = length - n
    temp = ans
    while steps_to_nth_plus_one_node > 0:
        steps_to_nth_plus_one_node -= 1
        temp = temp.next

    temp.next = temp.next.next

    return ans.next
Example #17
0
def test_full_binary_tree():
    """
    a full binary tree is a tree in which every node has 0 or 2 children

        5
       / \
      42  10
     /  \
    6   10
       /  \
      3    4
    """
    node10 = Node(10, left=Node(3), right=Node(4))
    node42 = Node(42, left=Node(6), right=node10)
    root = Node(5, left=node42, right=Node(10))

    assert inorder_traversal(root) == [6, 42, 3, 10, 4, 5, 10]
def test_left_branch():
    assert get_nearest_ancestor(root, 5, 19) == Node(10)
def test_typical_case():
    assert get_nearest_ancestor(root, 10, 30) == Node(20)
import pytest
from src.algorithms.tree_questions.get_nearest_ancestor import get_nearest_ancestor
from src.algorithms.node import Node


def test_typical_case():
    assert get_nearest_ancestor(root, 10, 30) == Node(20)


def test_left_branch():
    assert get_nearest_ancestor(root, 5, 19) == Node(10)


root = Node(20)
root.left = Node(10)
root.right = Node(30)
root.left.left = Node(5)
root.left.right = Node(19)
root.right.left = Node(25)
root.right.right = Node(41)
def test_simplest_valid_bst():
    root = Node(2, left=Node(1), right=Node(3))

    assert is_valid_bst(root) is True
def test_same_value_nodes_should_not_be_valid_bst():
    root = Node(1, left=Node(1), right=Node(1))

    assert is_valid_bst(root) is False
Example #23
0
def test_easy_case():
    assert get_nearest_ancestor_v2(left_child, right_child) == Node(42)
def test_list1_is_longer():
    list2 = Node(1, next=Node(2, next=Node(4)))
    list1 = Node(1, next=Node(3, next=Node(4, next=Node(5))))
    expected = Node(
        1,
        next=Node(
            1,
            next=Node(2,
                      next=Node(2,
                                next=Node(3,
                                          next=Node(4,
                                                    next=Node(
                                                        4, next=Node(5)))))),
        ),
    )

    assert merge_two_lists(list1, list2) == expected
Example #25
0
def test_unbalanced_at_right_child():
    root = Node(1)

    root_left = Node(2, left=Node(3), right=Node(4))
    root.left = root_left

    root_right = Node(5)
    root_right_right = Node(6, left=Node(7))
    root_right.right = root_right_right
    root.right = root_right

    assert is_balanced(root) is False
Example #26
0
def test_single_node_should_be_true():
    assert is_balanced(Node(2)) is True
Example #27
0
def test_simple_case_should_be_false():
    root = Node(1)

    root_right = Node(2)

    root_left = Node(2)
    root_left.right = Node(3)
    root_lower_left = Node(3, left=Node(4), right=Node(4))
    root_left.left = root_lower_left

    root.left = root_left
    root.right = root_right

    assert is_balanced(root) is False
def test_list2_is_null():
    list2 = None
    list1 = Node(1, next=Node(3, next=Node(4, next=Node(5))))
    expected = Node(1, next=Node(3, next=Node(4, next=Node(5))))

    assert merge_two_lists(list1, list2) == expected
def test_example():
    list1 = Node(1, next=Node(2, next=Node(4)))
    list2 = Node(1, next=Node(3, next=Node(4)))
    expected = Node(
        1,
        next=Node(1,
                  next=Node(2,
                            next=Node(2,
                                      next=Node(3, next=Node(4,
                                                             next=Node(4)))))),
    )

    assert merge_two_lists(list1, list2) == expected
Example #30
0
def test_single_tree():
    assert inorder_traversal(Node(2)) == [2]