Add utils.py; update unit tests

Author: nickolashkraus

tests/test_invert_binary_tree.py

@@ -7,21 +7,21 @@
 from unittest import TestCase
 
 from src.invert_binary_tree import Solution
-from tests.utils import bfs, create_binary_tree
+from tests.utils import create_bfs_list_from_binary_tree, create_binary_tree_from_list
 
 
 class TestSolution(TestCase):
     def test_1(self):
         exp = [4, 7, 2, 9, 6, 3, 1]
-        t = create_binary_tree([4, 2, 7, 1, 3, 6, 9])
-        assert bfs(Solution().invertTree(t)) == exp
+        t = create_binary_tree_from_list([4, 2, 7, 1, 3, 6, 9])
+        assert create_bfs_list_from_binary_tree(Solution().invertTree(t)) == exp
 
     def test_2(self):
         exp = [2, 3, 1]
-        t = create_binary_tree([2, 1, 3])
-        assert bfs(Solution().invertTree(t)) == exp
+        t = create_binary_tree_from_list([2, 1, 3])
+        assert create_bfs_list_from_binary_tree(Solution().invertTree(t)) == exp
 
     def test_3(self):
         exp = []
-        t = create_binary_tree([])
-        assert bfs(Solution().invertTree(t)) == exp
+        t = create_binary_tree_from_list([])
+        assert create_bfs_list_from_binary_tree(Solution().invertTree(t)) == exp

tests/test_linked_list_cycle.py

@@ -8,21 +8,21 @@
 
 from src.linked_list_cycle import Solution
 
-from .utils import create_cyclic_linked_list
+from .utils import create_cyclic_linked_list_from_list
 
 
 class TestSolution(TestCase):
     def test_1(self):
         exp = True
-        l = create_cyclic_linked_list([3, 2, 0, -4], 1)
+        l = create_cyclic_linked_list_from_list([3, 2, 0, -4], 1)
         assert Solution().hasCycle(l) == exp
 
     def test_2(self):
         exp = True
-        l = create_cyclic_linked_list([1, 2], 0)
+        l = create_cyclic_linked_list_from_list([1, 2], 0)
         assert Solution().hasCycle(l) == exp
 
     def test_3(self):
         exp = False
-        l = create_cyclic_linked_list([1], -1)
+        l = create_cyclic_linked_list_from_list([1], -1)
         assert Solution().hasCycle(l) == exp

tests/test_maximum_depth_of_binary_tree.py

@@ -7,16 +7,16 @@
 from unittest import TestCase
 
 from src.maximum_depth_of_binary_tree import Solution
-from tests.utils import create_binary_tree
+from tests.utils import create_binary_tree_from_list
 
 
 class TestSolution(TestCase):
     def test_1(self):
         exp = 3
-        root = create_binary_tree([3, 9, 20, None, None, 15, 7])
+        root = create_binary_tree_from_list([3, 9, 20, None, None, 15, 7])
         assert Solution().maxDepth(root) == exp
 
     def test_2(self):
         exp = 2
-        root = create_binary_tree([1, None, 2])
+        root = create_binary_tree_from_list([1, None, 2])
         assert Solution().maxDepth(root) == exp

tests/test_same_tree.py

@@ -7,24 +7,24 @@
 from unittest import TestCase
 
 from src.same_tree import Solution
-from tests.utils import create_binary_tree
+from tests.utils import create_binary_tree_from_list
 
 
 class TestSolution(TestCase):
     def test_1(self):
         exp = True
-        p = create_binary_tree([1, 2, 3])
-        q = create_binary_tree([1, 2, 3])
+        p = create_binary_tree_from_list([1, 2, 3])
+        q = create_binary_tree_from_list([1, 2, 3])
         assert Solution().isSameTree(p, q) == exp
 
     def test_2(self):
         exp = False
-        p = create_binary_tree([1, 2])
-        q = create_binary_tree([1, None, 2])
+        p = create_binary_tree_from_list([1, 2])
+        q = create_binary_tree_from_list([1, None, 2])
         assert Solution().isSameTree(p, q) == exp
 
     def test_3(self):
         exp = False
-        p = create_binary_tree([1, 2, 1])
-        q = create_binary_tree([1, 1, 2])
+        p = create_binary_tree_from_list([1, 2, 1])
+        q = create_binary_tree_from_list([1, 1, 2])
         assert Solution().isSameTree(p, q) == exp

tests/test_subtree_of_another_tree.py

@@ -7,30 +7,30 @@
 from unittest import TestCase
 
 from src.subtree_of_another_tree import Solution
-from tests.utils import create_binary_tree
+from tests.utils import create_binary_tree_from_list
 
 
 class TestSolution(TestCase):
     def test_1(self):
         exp = True
-        r = create_binary_tree([3, 4, 5, 1, 2])
-        s = create_binary_tree([4, 1, 2])
+        r = create_binary_tree_from_list([3, 4, 5, 1, 2])
+        s = create_binary_tree_from_list([4, 1, 2])
         assert Solution().isSubtree(r, s) == exp
 
     def test_2(self):
         exp = False
-        r = create_binary_tree([3, 4, 5, 1, 2, None, None, None, None, 0])
-        s = create_binary_tree([4, 1, 2])
+        r = create_binary_tree_from_list([3, 4, 5, 1, 2, None, None, None, None, 0])
+        s = create_binary_tree_from_list([4, 1, 2])
         assert Solution().isSubtree(r, s) == exp
 
     def test_3(self):
         exp = True
-        r = create_binary_tree([1, 1])
-        s = create_binary_tree([1])
+        r = create_binary_tree_from_list([1, 1])
+        s = create_binary_tree_from_list([1])
         assert Solution().isSubtree(r, s) == exp
 
     def test_4(self):
         exp = False
-        r = create_binary_tree([3, 4, 5, 1, None, 2])
-        s = create_binary_tree([3, 1, 2])
+        r = create_binary_tree_from_list([3, 4, 5, 1, None, 2])
+        s = create_binary_tree_from_list([3, 1, 2])
         assert Solution().isSubtree(r, s) == exp

tests/test_validate_binary_search_tree.py

@@ -7,21 +7,21 @@
 from unittest import TestCase
 
 from src.validate_binary_search_tree import Solution
-from tests.utils import create_binary_tree
+from tests.utils import create_binary_tree_from_list
 
 
 class TestSolution(TestCase):
     def test_1(self):
         exp = True
-        root = create_binary_tree([2, 1, 3])
+        root = create_binary_tree_from_list([2, 1, 3])
         assert Solution().isValidBST(root) == exp
 
     def test_2(self):
         exp = False
-        root = create_binary_tree([5, 1, 4, None, None, 3, 6])
+        root = create_binary_tree_from_list([5, 1, 4, None, None, 3, 6])
         assert Solution().isValidBST(root) == exp
 
     def test_3(self):
         exp = False
-        root = create_binary_tree([2, 2, 2])
+        root = create_binary_tree_from_list([2, 2, 2])
         assert Solution().isValidBST(root) == exp

tests/utils.py

@@ -0,0 +1,127 @@
+"""
+Utility functions for testing.
+"""
+
+from collections import deque
+
+from src.classes import ListNode, TreeNode
+
+
+def create_linked_list_from_list(l: list[int]) -> ListNode | None:
+    """
+    Creates a linked list from a list of integers, where each element of the
+    list becomes a node in the linked list. Returns the head of the linked
+    list.
+    """
+    if not l:
+        return None
+    head = ListNode(l[0])
+    curr = head
+    for val in l[1:]:
+        curr.next = ListNode(val)
+        curr = curr.next
+    return head
+
+
+def create_cyclic_linked_list_from_list(l: list[int], pos: int) -> ListNode | None:
+    """
+    Creates a cyclic linked list from a list of integers. The `pos` parameter
+    specifies the 0-based index from the list, which represents a node in the
+    linked list. The last node in the linked list points back to the node at
+    this position, creating a cycle.
+    """
+    if not l:
+        return None
+    head = ListNode(l[0])
+    curr = head
+    # `start` is the node that starts the cycle commonly referred to as the
+    # "cycle entry node" or "loop starting node".
+    start = None
+    for i, val in enumerate(l[1:]):
+        curr.next = ListNode(val)
+        if i == pos:
+            start = curr
+        curr = curr.next
+    curr.next = start
+    return head
+
+
+def create_list_from_linked_list(head: ListNode | None) -> list[int]:
+    """
+    Creates a list of integers from the head of a linked list.
+    """
+    if not head:
+        return []
+    l: list[int] = []
+    while head:
+        l.append(head.val)
+        head = head.next
+    return l
+
+
+def create_binary_tree_from_list(l: list[int | None]) -> TreeNode | None:
+    """
+    Creates a binary tree from a list of integers, where each element of the
+    list becomes a node in the binary tree. Returns the root of the binary
+    tree.
+
+    For zero-based arrays, the rule is that a node at position `i` has children
+    at positions `2*i+1` and `2*i+2`; in the other direction, a node at
+    position `i` has a parent at position `(i-1)/2` (which rounds down). This
+    is equivalent to storing a binary tree in an array by reading through the
+    tree in breadth-first search order.
+
+    NOTE: Gaps in the binary tree should be denoted by `None`.
+    """
+    if not l:
+        return None
+    return _create_binary_tree_from_list(l, 0)
+
+
+def _create_binary_tree_from_list(l: list[int | None], i: int) -> TreeNode | None:
+    """
+    Helper function for `create_binary_tree_from_list()`. Given a list of
+    integers and an index, which represents a node in the binary tree,
+    recursively create the binary tree.
+    """
+    # If the index is out of bounds of the array, the previous node was a leaf,
+    # therefore return None.
+    # If the current node is None, it represents a gap in the binary tree,
+    # therefore return None.
+    if i >= len(l) or l[i] is None:
+        return None
+
+    # Create node with current value
+    node = TreeNode(l[i])
+
+    # Recursively build left and right subtrees using child indices.
+    node.left = _create_binary_tree_from_list(l, 2 * i + 1)
+    node.right = _create_binary_tree_from_list(l, 2 * i + 2)
+
+    return node
+
+
+def create_bfs_list_from_binary_tree(root: TreeNode | None) -> list[int]:
+    """
+    Creates a list of integers in breadth-first search order given the root
+    node of a binary tree.
+
+    Breadth-first order always attempts to visit the node closest to the root
+    that it has not already visited. This is also called a level-order
+    traversal.
+    """
+    if not root:
+        return []
+
+    l: list[int] = []
+    q: deque[TreeNode] = deque([root])
+
+    while q:
+        curr: TreeNode = q.popleft()
+        l.append(curr.val)
+        if curr.left:
+            q.append(curr.left)
+        if curr.right:
+            q.append(curr.right)
+
+    return l