refactor(datastructures, trees): cleanup typing

Author: BrianLusina

datastructures/trees/__init__.py

@@ -1,237 +1,4 @@
-from typing import List, Generic, TypeVar, Any
-from abc import ABC, abstractmethod
-from .node import TreeNode
+from datastructures.trees.tree import Tree, TreeNode, T
+from datastructures.trees.binary import BinaryTree, BinaryTreeNode
 
-T = TypeVar("T", bound=Any)
-
-
-class Tree(ABC, Generic[T]):
-    """
-    Tree abstract base class that defines common methods & properties of a typical Tree data structure
-    """
-
-    @abstractmethod
-    def __len__(self) -> int:
-        """
-        Calculates the number of nodes in the Tree
-        :returns: number of nodes in the tree
-        """
-        raise NotImplementedError("This method has not been implemented")
-
-    @abstractmethod
-    def next(self) -> int:
-        raise NotImplementedError("This method has not been implemented")
-
-    @abstractmethod
-    def height(self) -> int:
-        """
-        Returns the height of the Tree. That is, the number of edges between the root node and the furthest leaf node.
-        This can also be the maximum depth of the Tree
-        This is the number of links from the root to the furthest leaf.
-        """
-        raise NotImplementedError("This method has not been implemented")
-
-    @abstractmethod
-    def lowest_common_ancestor(
-        self, node_one: TreeNode, node_two: TreeNode
-    ) -> TreeNode:
-        """
-        Returns the lowest common ancestor of 2 nodes in the Tree.
-        :param node_one
-        :param node_two
-        :returns the lowest common ancestor of the Tree
-        :rtype TreeNode
-        """
-        raise NotImplementedError("This method has not been implemented")
-
-    @abstractmethod
-    def has_next(self) -> bool:
-        raise NotImplementedError("This method has not been implemented")
-
-    @abstractmethod
-    def increasing_order_traversal(self) -> TreeNode:
-        """
-        Rearranges the tree in in-order so that the leftmost node in the tree is now the root of the tree
-        and every node has no left child and only one right child
-        :returns root of tree of new tree
-        """
-        raise NotImplementedError("This method has not been implemented")
-
-    @abstractmethod
-    def get_depth(self) -> int:
-        """
-        Gets the depth of the tree or height of the tree
-        :returns height/depth of the tree
-        """
-        raise NotImplementedError("This method has not been implemented")
-
-    @abstractmethod
-    def insert_node(self, value) -> TreeNode:
-        """
-        Based on the type of tree, this inserts a node in the Tree
-        """
-        raise NotImplementedError("This method has not been implemented")
-
-    @abstractmethod
-    def paths(self) -> list:
-        """
-        Prints all the paths of a Tree from root node to leaf nodes
-        """
-        raise NotImplementedError("This method has not been implemented")
-
-    @abstractmethod
-    def level_order_traversal(self) -> List[T]:
-        raise NotImplementedError("This method has not been implemented")
-
-    def reverse_level_order_traversal(self) -> List[T]:
-        """
-        Performs a level order traversal on the tree in reverse order where the leaf nodes are first iterated through
-        and then the internal nodes before the root node is added to the collection
-
-        Complexity:
-        Where `n` is the number of nodes in the tree
-
-        Time Complexity: O(n) as each node in the tree is traversed
-        Space Complexity: O(n) as each node or node data is stored in a list/collection to be returned
-
-        Returns:
-            List: list of nodes or node values/data traversed in a reverse level order fashion.
-        """
-        raise NotImplementedError("This method has not been implemented")
-
-    @abstractmethod
-    def pre_order_traversal(self) -> List[T]:
-        """Traverses the tree in pre-order walking the left subtree before finally walking the right subtree returning
-        a list of values on each node
-
-        Complexity:
-        Time Complexity O(n): where n is the number of nodes in the tree, as the algorithm has to traverse all the nodes
-        in the tree
-
-        Space Complexity O(h), where h is the height of the tree
-
-        Returns:
-            list: list of values of each node
-        """
-        raise NotImplementedError("This method has not been implemented")
-
-    def inorder_traversal(self) -> List[T]:
-        """
-        Walks the left subtree first, then visits the current node, and finally walks the right subtree
-        The algorithm looks something like this:
-
-        1. Check if the current node is empty/null.
-        2. Traverse the left subtree by recursively calling the in-order method.
-        3. Display the data part of the root (or current node).
-        4. Traverse the right subtree by recursively calling the in-order method.
-
-        Complexity:
-        Where `n` is the number of nodes in the tree
-
-        Time Complexity: O(n) as each node in the tree is traversed
-        Space Complexity: O(n) as each node or node data is stored in a list/collection to be returned
-
-        Returns:
-            List: list of nodes or node values/data traversed in inorder traversal fashion.
-        """
-
-    def post_order_traversal(self) -> List[T]:
-        """
-        Walks the left subtree first, then the right subtree and finally visits the current node
-        The algorithm looks something like this:
-
-        1. Check if the current node is empty/null.
-        2. Traverse the left subtree by recursively calling the post-order method.
-        3. Traverse the right subtree by recursively calling the post-order method.
-        4. Display the data part of the root (or current node).
-
-        Complexity:
-        Where `n` is the number of nodes in the tree
-
-        Time Complexity: O(n) as each node in the tree is traversed
-        Space Complexity: O(n) as each node or node data is stored in a list/collection to be returned
-
-        Returns:
-            List: list of nodes or node values/data traversed in inorder traversal fashion.
-        """
-
-    @abstractmethod
-    def is_balanced(self) -> bool:
-        """
-        Checks if this tree is balanced.
-        A balanced tree is a tree where every node has 0 or more n children for n-ary trees or for binary trees, where
-        the heights of its left and right subtrees differ by at most 1 or 0 and both subtrees are also balanced.
-        @return: True if the tree is balanced, false otherwise
-        """
-        raise NotImplementedError("This method has not yet been implemented")
-
-    @abstractmethod
-    def leaf_similar(self, other: "Tree") -> bool:
-        """
-        Returns true if this tree has similar leaf value sequence to another tree.
-        For example: If this tree has nodes = [3,5,1,6,2,9,8,null,null,7,4] and other tree has nodes =
-        [3,5,1,6,7,4,2,null,null,null,null,null,null,9,8]. Then the leaf value sequence of both is [6,7,4,9,8] which is
-        similar
-        @param other: Other tree
-        @return: True if the sequence of both tree's leaves is similar, false otherwise
-        """
-        raise NotImplementedError("not yet implemented")
-
-    @abstractmethod
-    def number_of_good_nodes(self) -> int:
-        """
-        Finds the number of good nodes in a tree. A good node is a node in which in the path from root to the node there
-        are no nodes with a value greater than it
-        @return: The number of good nodes
-        """
-        raise NotImplementedError("not yet implemented")
-
-    @abstractmethod
-    def path_sum(self, target: T) -> int:
-        """Returns the number of paths where the sum of the values along the path equals target
-
-        Args:
-            target (T): The target that the sum of values along the path must equal
-
-        Returns:
-            int: The number of paths along which the values equal the target
-        """
-        raise NotImplementedError("not yet implemented")
-
-    @abstractmethod
-    def paths_to_target(self, target: T) -> List[T]:
-        """Returns the paths where the sum of the values along the path equals to the given target
-
-        Args:
-            target (T): The target that the sum of values along the path must equal
-
-        Returns:
-            list: The paths along which the values equal the target
-        """
-        raise NotImplementedError("not yet implemented")
-
-    def max_level_sum(self) -> int:
-        """Returns the smallest level x such that the sum of all the values of nodes at level x is maximal
-
-        Returns:
-            int: maximum value at level x
-        """
-        raise NotImplementedError("not yet implemented")
-
-    @abstractmethod
-    def serialize(self) -> str:
-        """Serializes a tree into a string
-        Returns:
-            str: string representation of tree.
-        """
-        raise NotImplementedError("not yet implemented")
-
-    @staticmethod
-    def deserialize(tree_str: str) -> "Tree":
-        """Serializes a tree into a string
-        Args:
-            tree_str (str): string representation of tree
-        Returns:
-            Tree: Tree deserialized from string
-        """
-        raise NotImplementedError("not yet implemented")
+__all__ = ["Tree", "TreeNode", "BinaryTree", "BinaryTreeNode"]

datastructures/trees/binary/__init__.py

@@ -0,0 +1,27 @@
+from datastructures.trees.binary.tree import (
+    BinaryTree,
+    create_tree_from_nodes,
+    level_order_traversal,
+    longest_uni_value_path,
+)
+from datastructures.trees.binary.node import BinaryTreeNode
+from datastructures.trees.binary.utils import (
+    lowest_common_ancestor,
+    lowest_common_ancestor_ptr,
+    connect_all_siblings,
+    connect_all_siblings_ptr,
+    mirror_binary_tree,
+)
+
+__all__ = [
+    "BinaryTree",
+    "BinaryTreeNode",
+    "create_tree_from_nodes",
+    "level_order_traversal",
+    "longest_uni_value_path",
+    "lowest_common_ancestor",
+    "lowest_common_ancestor_ptr",
+    "connect_all_siblings",
+    "connect_all_siblings_ptr",
+    "mirror_binary_tree",
+]

datastructures/trees/binary/search_tree/avl/__init__.py

@@ -1,5 +1,5 @@
 from typing import Optional, List
-from datastructures.trees import Tree, T
+from datastructures.trees.tree import Tree, T
 from .node import AvlTreeNode
 
 

datastructures/trees/binary/search_tree/binary_search_tree.py

@@ -456,7 +456,7 @@ def increasing_order_traversal(self) -> Optional[BinaryTreeNode]:
         if not self.root:
             return None
 
-        def inorder(node: BinaryTreeNode):
+        def inorder(node: Optional[BinaryTreeNode]):
             if node:
                 yield from inorder(node.left)
                 yield node.data

datastructures/trees/binary/tree/__init__.py

@@ -1,3 +1,13 @@
 from datastructures.trees.binary.tree.binary_tree import BinaryTree
+from datastructures.trees.binary.tree.binary_tree_utils import (
+    create_tree_from_nodes,
+    level_order_traversal,
+    longest_uni_value_path,
+)
 
-__all__ = ["BinaryTree"]
+__all__ = [
+    "BinaryTree",
+    "create_tree_from_nodes",
+    "level_order_traversal",
+    "longest_uni_value_path",
+]

datastructures/trees/binary/tree/binary_tree.py

@@ -4,7 +4,8 @@
 from itertools import chain
 
 from datastructures.stacks.dynamic import DynamicSizeStack
-from datastructures.trees import Tree, TreeNode, T
+from datastructures.trees.tree import Tree, T
+from datastructures.trees.node import TreeNode
 from datastructures.trees.binary.node import BinaryTreeNode
 from datastructures.trees.binary.tree.binary_tree_utils import longest_uni_value_path
 from datastructures.queues.fifo import FifoQueue
@@ -159,7 +160,7 @@ def pre_order_traversal(self) -> List[Any]:
         if not self.root:
             return data
 
-        def pre_order_helper(root: BinaryTreeNode):
+        def pre_order_helper(root: Optional[BinaryTreeNode]):
             if not root:
                 return
             data.append(root.data)
@@ -174,7 +175,7 @@ def inorder_traversal(self) -> List[T]:
         if not self.root:
             return data
 
-        def inorder_helper(root: BinaryTreeNode):
+        def inorder_helper(root: Optional[BinaryTreeNode]):
             if not root:
                 return
             inorder_helper(root.left)
@@ -189,7 +190,7 @@ def post_order_traversal(self) -> List[T]:
         if not self.root:
             return data
 
-        def post_order_helper(root: BinaryTreeNode):
+        def post_order_helper(root: Optional[BinaryTreeNode]):
             if not root:
                 return
             post_order_helper(root.left)

datastructures/trees/binary/tree/test_binary_tree.py

@@ -729,25 +729,6 @@ def test_1(self):
         self.assertListEqual(expected, actual)
 
 
-class BinaryTreeInOrderTraversal(unittest.TestCase):
-    def test_1(self):
-        """Should return [A, B, C, D, E, F, G, H, I]"""
-        expected = ["A", "B", "C", "D", "E", "F", "G", "H", "I"]
-        right = BinaryTreeNode("G", right=BinaryTreeNode("I", left=BinaryTreeNode("H")))
-        left = BinaryTreeNode(
-            "B",
-            left=BinaryTreeNode("A"),
-            right=BinaryTreeNode(
-                "D", left=BinaryTreeNode("C"), right=BinaryTreeNode("E")
-            ),
-        )
-        root = BinaryTreeNode("F", left=left, right=right)
-
-        tree = BinaryTree(root=root)
-        actual = tree.inorder_traversal()
-        self.assertListEqual(expected, actual)
-
-
 class BinaryTreePostOrderTraversal(unittest.TestCase):
     def test_1(self):
         """Should return [A, C, E, D, B, H, I, G, F]"""

datastructures/trees/binary/tree/test_binary_tree_inorder_traversal.py

@@ -0,0 +1,27 @@
+import unittest
+
+from datastructures.trees.binary.tree import BinaryTree
+from datastructures.trees.binary.node import BinaryTreeNode
+
+
+class BinaryTreeInOrderTraversal(unittest.TestCase):
+    def test_1(self):
+        """Should return [A, B, C, D, E, F, G, H, I]"""
+        expected = ["A", "B", "C", "D", "E", "F", "G", "H", "I"]
+        right = BinaryTreeNode("G", right=BinaryTreeNode("I", left=BinaryTreeNode("H")))
+        left = BinaryTreeNode(
+            "B",
+            left=BinaryTreeNode("A"),
+            right=BinaryTreeNode(
+                "D", left=BinaryTreeNode("C"), right=BinaryTreeNode("E")
+            ),
+        )
+        root = BinaryTreeNode("F", left=left, right=right)
+
+        tree = BinaryTree(root=root)
+        actual = tree.inorder_traversal()
+        self.assertListEqual(expected, actual)
+
+
+if __name__ == "__main__":
+    unittest.main()

datastructures/trees/nary/__init__.py

@@ -1,6 +1,6 @@
 from typing import List, Any
 from collections import deque
-from .. import Tree, T
+from datastructures.trees.tree import Tree, T
 from .node import NAryNode