core-data-structures 1.3.0__tar.gz → 1.4.0__tar.gz

{core_data_structures-1.3.0 → core_data_structures-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: core-data-structures
-Version: 1.3.0
+Version: 1.4.0
 Summary: This project/library contains commons data structures...
 Author-email: Alejandro Cora González <alek.cora.glez@gmail.com>
 Maintainer: Alejandro Cora González

{core_data_structures-1.3.0 → core_data_structures-1.4.0}/core_data_structures.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: core-data-structures
-Version: 1.3.0
+Version: 1.4.0
 Summary: This project/library contains commons data structures...
 Author-email: Alejandro Cora González <alek.cora.glez@gmail.com>
 Maintainer: Alejandro Cora González

{core_data_structures-1.3.0 → core_data_structures-1.4.0}/core_data_structures.egg-info/SOURCES.txt

@@ -18,5 +18,6 @@ data_structures/lists/base.py
 data_structures/lists/double_linked_list.py
 data_structures/lists/singly_linked_list.py
 data_structures/trees/__init__.py
+data_structures/trees/base.py
 data_structures/trees/binary_tree.py
 data_structures/trees/simple_tree.py

core_data_structures-1.4.0/data_structures/trees/base.py

@@ -0,0 +1,46 @@
+# -*- coding: utf-8 -*-
+
+"""Node with left/right child references, shared by every binary tree."""
+
+from typing import Optional
+
+from core_mixins.compatibility import Self
+
+from data_structures.base import Node as BaseNode
+from data_structures.base import T
+
+__all__ = [
+    "Node",
+]
+
+
+class Node(BaseNode[T]):
+    """Node with references to its left and right children."""
+
+    def __init__(
+        self,
+        value: Optional[T] = None,
+        left: Optional[Self] = None,
+        right: Optional[Self] = None,
+    ) -> None:
+        super().__init__(value=value)
+        self._left = left
+        self._right = right
+
+    @property
+    def left(self) -> Optional[Self]:
+        """The left child of the node, if any."""
+        return self._left
+
+    @left.setter
+    def left(self, node: Optional[Self]) -> None:
+        self._left = node
+
+    @property
+    def right(self) -> Optional[Self]:
+        """The right child of the node, if any."""
+        return self._right
+
+    @right.setter
+    def right(self, node: Optional[Self]) -> None:
+        self._right = node

core_data_structures-1.4.0/data_structures/trees/binary_tree.py

@@ -0,0 +1,246 @@
+# -*- coding: utf-8 -*-
+
+"""Binary tree data structure with recursive and iterative traversal algorithms."""
+
+from queue import Queue
+from typing import Generic, Iterator, List, Optional, cast
+
+from data_structures.base import T
+from data_structures.trees.base import Node
+
+
+class BinaryTree(Generic[T]):
+    """
+    In computer science, a binary tree is a tree data structure in which
+    each node has at most two children, referred to as the left child
+    and the right child.
+    """
+
+    def __init__(self, value: Optional[T] = None) -> None:
+        self._root: Optional[Node[T]] = None if value is None else Node(value)
+
+    def __iter__(self) -> Iterator[T]:
+        yield from self._iter(self._root)
+
+    @classmethod
+    def _iter(cls, node: Optional[Node[T]]) -> Iterator[T]:
+        if node is None:
+            return
+
+        yield from cls._iter(node.left)
+        yield cast(T, node.value)
+        yield from cls._iter(node.right)
+
+    def __len__(self) -> int:
+        return self._count(self._root)
+
+    @classmethod
+    def _count(cls, node: Optional[Node[T]]) -> int:
+        if node is None:
+            return 0
+
+        return 1 + cls._count(node.left) + cls._count(node.right)
+
+    def __contains__(self, value: T) -> bool:
+        return any(node_value == value for node_value in self)
+
+    def __repr__(self) -> str:
+        return f"{type(self).__name__}({self.level_order()!r})"
+
+    @property
+    def root(self) -> Optional[Node[T]]:
+        """The root node of the tree."""
+        return self._root
+
+    def pre_order(self) -> List[T]:
+        """
+        >>> tree = create_example_tree()
+        >>> tree.pre_order()
+        [1, 2, 4, 8, 9, 5, 10, 11, 3, 6, 12, 13, 7, 14, 15]
+        """
+
+        return self._pre_order(self._root)
+
+    @classmethod
+    def _pre_order(cls, node: Optional[Node[T]]) -> List[T]:
+        if node is None:
+            return []
+
+        res = [cast(T, node.value)]
+        res.extend(cls._pre_order(node.left))
+        res.extend(cls._pre_order(node.right))
+        return res
+
+    def pre_order_iterative(self) -> List[T]:
+        """
+        >>> tree = create_example_tree()
+        >>> tree.pre_order_iterative()
+        [1, 2, 4, 8, 9, 5, 10, 11, 3, 6, 12, 13, 7, 14, 15]
+        """
+
+        stack: List[Node[T]] = []
+        node: Optional[Node[T]] = self._root
+        res: List[T] = []
+
+        while stack or node:
+            while node:
+                res.append(cast(T, node.value))
+                stack.append(node)
+                node = node.left
+
+            node = stack.pop()
+            node = node.right
+
+        return res
+
+    def in_order(self) -> List[T]:
+        """
+        >>> tree = create_example_tree()
+        >>> tree.in_order()
+        [8, 4, 9, 2, 10, 5, 11, 1, 12, 6, 13, 3, 14, 7, 15]
+        """
+
+        return self._in_order(self._root)
+
+    @classmethod
+    def _in_order(cls, node: Optional[Node[T]]) -> List[T]:
+        if node is None:
+            return []
+
+        res = cls._in_order(node.left)
+        res.append(cast(T, node.value))
+        res.extend(cls._in_order(node.right))
+        return res
+
+    def in_order_iterative(self) -> List[T]:
+        """
+        >>> tree = create_example_tree()
+        >>> tree.in_order_iterative()
+        [8, 4, 9, 2, 10, 5, 11, 1, 12, 6, 13, 3, 14, 7, 15]
+        """
+
+        res: List[T] = []
+        stack: List[Node[T]] = []
+        node: Optional[Node[T]] = self._root
+
+        while stack or node:
+            while node:
+                stack.append(node)
+                node = node.left
+
+            node = stack.pop()
+            res.append(cast(T, node.value))
+            node = node.right
+
+        return res
+
+    def post_order(self) -> List[T]:
+        """
+        >>> tree = create_example_tree()
+        >>> tree.post_order()
+        [8, 9, 4, 10, 11, 5, 2, 12, 13, 6, 14, 15, 7, 3, 1]
+        """
+
+        return self._post_order(self._root)
+
+    @classmethod
+    def _post_order(cls, node: Optional[Node[T]]) -> List[T]:
+        if node is None:
+            return []
+
+        res = cls._post_order(node.left)
+        res.extend(cls._post_order(node.right))
+        res.append(cast(T, node.value))
+        return res
+
+    def post_order_iterative(self) -> List[T]:
+        """
+        >>> tree = create_example_tree()
+        >>> tree.post_order_iterative()
+        [8, 9, 4, 10, 11, 5, 2, 12, 13, 6, 14, 15, 7, 3, 1]
+        """
+
+        if self._root is None:
+            return []
+
+        stack: List[Node[T]] = [self._root]
+        stack_tmp: List[Node[T]] = []
+
+        while stack:
+            node = stack.pop()
+            if node.left:
+                stack.append(node.left)
+
+            if node.right:
+                stack.append(node.right)
+
+            stack_tmp.append(node)
+
+        res: List[T] = []
+        while stack_tmp:
+            res.append(cast(T, stack_tmp.pop().value))
+
+        return res
+
+    def level_order(self) -> List[T]:
+        """
+        >>> tree = create_example_tree()
+        >>> tree.level_order()
+        [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
+        """
+
+        res: List[T] = []
+        if self._root is None:
+            return res
+
+        q: Queue[Node[T]] = Queue()
+        q.put(self._root)
+
+        while not q.empty():
+            node_dequeued = q.get()
+            res.append(cast(T, node_dequeued.value))
+
+            if node_dequeued.left:
+                q.put(node_dequeued.left)
+
+            if node_dequeued.right:
+                q.put(node_dequeued.right)
+
+        return res
+
+    def depth(self) -> int:
+        """
+        The maximum depth of a binary tree is the number of nodes from the
+        root down to the furthest leaf node. In other words, it is
+        the height of a binary tree.
+
+        >>> tree = create_example_tree()
+        >>> tree.depth()
+        4
+        """
+
+        return self._depth(self._root)
+
+    @classmethod
+    def _depth(cls, node: Optional[Node[T]]) -> int:
+        if node is None:
+            return 0
+
+        return 1 + max(cls._depth(node.left), cls._depth(node.right))
+
+
+def create_example_tree() -> BinaryTree[int]:
+    """ Build and return a complete binary tree with 15 nodes for testing. """
+
+    tree = BinaryTree(1)
+    root = cast(Node[int], tree.root)
+    nodes = [Node(value) for value in range(2, 16)]
+
+    root.left, root.right = nodes[0], nodes[1]
+    nodes[0].left, nodes[0].right = nodes[2], nodes[3]
+    nodes[1].left, nodes[1].right = nodes[4], nodes[5]
+    nodes[2].left, nodes[2].right = nodes[6], nodes[7]
+    nodes[3].left, nodes[3].right = nodes[8], nodes[9]
+    nodes[4].left, nodes[4].right = nodes[10], nodes[11]
+    nodes[5].left, nodes[5].right = nodes[12], nodes[13]
+    return tree

{core_data_structures-1.3.0 → core_data_structures-1.4.0}/pyproject.toml

@@ -9,7 +9,7 @@ build-backend = "setuptools.build_meta"
 [project]
 name = "core-data-structures"
 description = "This project/library contains commons data structures..."
-version = "1.3.0"
+version = "1.4.0"
 
 authors = [
     {name = "Alejandro Cora González", email = "alek.cora.glez@gmail.com"}

core_data_structures-1.3.0/data_structures/trees/binary_tree.py

@@ -1,230 +0,0 @@
-# -*- coding: utf-8 -*-
-
-"""Binary tree data structure with recursive and iterative traversal algorithms."""
-
-from queue import Queue
-from typing import List, Optional
-
-
-class BinaryTree:
-    """
-    In computer science, a binary tree is a tree data structure in which
-    each node has at most two children, which are referred to as the
-    left child and the right child...
-    """
-
-    def __init__(self, value) -> None:
-        self.value = value
-        self.right: Optional[BinaryTree] = None
-        self.left: Optional[BinaryTree] = None
-
-    @staticmethod
-    def create_example_tree():
-        """ Build and return a complete binary tree with 15 nodes for testing. """
-
-        root = BinaryTree(1)
-        tree_node2, tree_node3 = BinaryTree(2), BinaryTree(3)
-        tree_node4, tree_node5 = BinaryTree(4), BinaryTree(5)
-        tree_node6, tree_node7 = BinaryTree(6), BinaryTree(7)
-        tree_node8, tree_node9 = BinaryTree(8), BinaryTree(9)
-        tree_node10, tree_node11 = BinaryTree(10), BinaryTree(11)
-        tree_node12, tree_node13 = BinaryTree(12), BinaryTree(13)
-        tree_node14, tree_node15 = BinaryTree(14), BinaryTree(15)
-
-        root.left, root.right = tree_node2, tree_node3
-        tree_node2.left, tree_node2.right = tree_node4, tree_node5
-        tree_node3.left, tree_node3.right = tree_node6, tree_node7
-        tree_node4.left, tree_node4.right = tree_node8, tree_node9
-        tree_node5.left, tree_node5.right = tree_node10, tree_node11
-        tree_node6.left, tree_node6.right = tree_node12, tree_node13
-        tree_node7.left, tree_node7.right = tree_node14, tree_node15
-        return root
-
-    def pre_order(self) -> List:
-        """
-        >>> root = BinaryTree.create_example_tree()
-        >>> root.pre_order()
-        [1, 2, 4, 8, 9, 5, 10, 11, 3, 6, 12, 13, 7, 14, 15]
-        """
-
-        res = [self.value]
-        if self.left:
-            res.extend(self.left.pre_order())
-
-        if self.right:
-            res.extend(self.right.pre_order())
-
-        return res
-
-    def pre_order_iterative(self) -> List:
-        """
-        >>> root = BinaryTree.create_example_tree()
-        >>> root.pre_order_iterative()
-        [1, 2, 4, 8, 9, 5, 10, 11, 3, 6, 12, 13, 7, 14, 15]
-        """
-
-        stack: List[BinaryTree] = []
-        node: Optional[BinaryTree] = self
-        res = []
-
-        while stack or node:
-            while node:
-                res.append(node.value)
-                stack.append(node)
-                node = node.left
-
-            node = stack.pop()
-            node = node.right
-
-        return res
-
-    def in_order(self) -> List:
-        """
-        >>> root = BinaryTree.create_example_tree()
-        >>> root.in_order()
-        [8, 4, 9, 2, 10, 5, 11, 1, 12, 6, 13, 3, 14, 7, 15]
-        """
-
-        res = []
-        if self.left:
-            res.extend(self.left.in_order())
-
-        res.append(self.value)
-
-        if self.right:
-            res.extend(self.right.in_order())
-
-        return res
-
-    def in_order_iterative(self) -> List:
-        """
-        >>> root = BinaryTree.create_example_tree()
-        >>> root.in_order_iterative()
-        [8, 4, 9, 2, 10, 5, 11, 1, 12, 6, 13, 3, 14, 7, 15]
-        """
-
-        res = []
-        stack: List[BinaryTree] = []
-        node: Optional[BinaryTree] = self
-
-        while stack or node:
-            while node:
-                stack.append(node)
-                node = node.left
-
-            node = stack.pop()
-            res.append(node.value)
-            node = node.right
-
-        return res
-
-    def post_order(self) -> List:
-        """
-        >>> root = BinaryTree.create_example_tree()
-        >>> root.post_order()
-        [8, 9, 4, 10, 11, 5, 2, 12, 13, 6, 14, 15, 7, 3, 1]
-        """
-
-        res = []
-        if self.left:
-            res.extend(self.left.post_order())
-
-        if self.right:
-            res.extend(self.right.post_order())
-
-        res.append(self.value)
-        return res
-
-    def post_order_iterative(self) -> List:
-        """
-        >>> root = BinaryTree.create_example_tree()
-        >>> root.post_order_iterative()
-        [8, 9, 4, 10, 11, 5, 2, 12, 13, 6, 14, 15, 7, 3, 1]
-        """
-
-        stack: List[BinaryTree] = [self]
-        stack_tmp: List[BinaryTree] = []
-
-        while stack:
-            node = stack.pop()
-            if node.left:
-                stack.append(node.left)
-
-            if node.right:
-                stack.append(node.right)
-
-            stack_tmp.append(node)
-
-        res = []
-        while stack_tmp:
-            res.append(stack_tmp.pop().value)
-
-        return res
-
-    def level_order(self) -> List:
-        """
-        >>> root = BinaryTree.create_example_tree()
-        >>> root.level_order()
-        [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
-        """
-
-        res = []
-        q: Queue[BinaryTree] = Queue()
-        q.put(self)
-
-        while not q.empty():
-            node_dequeued = q.get()
-            res.append(node_dequeued.value)
-
-            if node_dequeued.left:
-                q.put(node_dequeued.left)
-
-            if node_dequeued.right:
-                q.put(node_dequeued.right)
-
-        return res
-
-    # def level_order_iterative(self) -> List:
-    #     """
-    #     >>> root = BinaryTree.create_example_tree()
-    #     >>> root.post_order_iterative()
-    #     [8, 9, 4, 10, 11, 5, 2, 12, 13, 6, 14, 15, 7, 3, 1]
-    #     """
-    #
-    #     stack: List[BinaryTree] = []
-    #     node, res = self, []
-    #
-    #     while stack or node:
-    #         while node.left:
-    #             stack.append(node)
-    #             node = node.left
-    #
-    #         res.append(node.value)
-    #         node = stack.pop()
-    #         node = node.right
-    #
-    #     return res
-
-    def depth(self):
-        """
-        The maximum depth of a binary tree is the number of nodes from the
-        root down to the furthest leaf node. In other words, it is
-        the height of a binary tree.
-
-        >>> root = BinaryTree.create_example_tree()
-        >>> root.depth()
-        4
-        """
-
-        if not self.left and not self.right:
-            return 1
-
-        depth_left = 0
-        if self.left:
-            depth_left = self.left.depth()
-
-        depth_right = 0
-        if self.right:
-            depth_right = self.right.depth()
-
-        return 1 + max(depth_left, depth_right)