stepps 0.2.0__tar.gz → 0.4.0__tar.gz

{stepps-0.2.0 → stepps-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stepps
-Version: 0.2.0
+Version: 0.4.0
 Summary: Useful algorithms in Python
 Author-email: Suhas Krishna Srivastava <suhas.srivastava@vaastav.tech>, Trinay Mitra <trinay.mitra@vaastav.tech>
 Maintainer-email: Suhas Krishna Srivastava <suhas.srivastava@vaastav.tech>
@@ -42,8 +42,8 @@ Dynamic: license-file
 **Fully typed, modular data structures and algorithms for binary trees in Python.**
 
 `stepps` provides generic binary tree and binary search tree implementations,
-tree traversal iterators, traversal-based tree builders, and tree visualization
-utilities.
+AVL balancing, red-black trees, tree traversal iterators, traversal-based tree
+builders, and tree visualization utilities.
 
 The project follows an interface-and-implementation architecture and uses
 Python generics and static typing throughout its APIs.
@@ -54,6 +54,10 @@ Python generics and static typing throughout its APIs.
 
 - Generic binary tree data structures.
 - Binary search tree implementation.
+- AVL tree balancing with configurable balance factor.
+- Red-black tree implementation.
+- Automatic balancing after AVL and red-black tree insert and delete operations.
+- Binary node creation through `get_binary_node(value)`.
 - Preorder, inorder, postorder, and level-order traversal iterators.
 - Tree builders for preorder, inorder, postorder, and level-order sequences.
 - Binary tree statistics and utility operations.
@@ -103,6 +107,11 @@ the default implementation.
 | `count_leaves()` | Returns the number of leaf nodes. |
 | `count_internal_nodes()` | Returns the number of internal nodes. |
 | `invert_tree()` | Inverts the tree in-place. |
+| `get_root()` | Returns the root node, or `None` if the tree is empty. |
+| `get_left_subtree()` | Returns the left subtree. |
+| `get_right_subtree()` | Returns the right subtree. |
+| `left_rotate()` | Performs a left rotation on the tree. |
+| `right_rotate()` | Performs a right rotation on the tree. |
 
 ---
 
@@ -138,6 +147,75 @@ are greater.
 
 ---
 
+## AVL Tree
+
+`AVL` defines the AVL balancing interface and `AVLImpl` provides the
+implementation.
+
+`AVLImpl` accepts a binary tree through its constructor and provides automatic
+balancing after insert and delete operations. The implementation supports LL,
+RR, LR, and RL balancing cases and a configurable balance factor.
+
+`AVL` and `AVLImpl` are available from `stepps.trees.balanced.avl_tree`.
+
+### AVL Tree Methods
+
+| Method | Description |
+|---|---|
+| `balance()` | Balances and returns the supplied binary tree. |
+| `insert(value)` | Inserts a value into the supplied tree and balances it. |
+| `delete(value)` | Deletes a value from the supplied tree and balances it. |
+
+The remaining binary tree operations are delegated to the supplied tree.
+
+---
+
+## Red-Black Tree
+
+`RedBlack` defines the red-black tree interface and `RedBlackImpl` provides the
+implementation.
+
+The red-black tree maintains BST ordering and uses node colors, rotations, and
+recoloring to maintain balance after insert and delete operations. Duplicate
+values are not inserted.
+
+`RedBlackImpl` accepts a binary tree through its constructor and supports
+creating a red-black tree from an existing binary tree.
+
+`RedBlack` and `RedBlackImpl` are available from
+`stepps.trees.balanced.rb_tree.red_black` and
+`stepps.trees.balanced.rb_tree.red_black_impl`, respectively.
+
+### Red-Black Tree Methods
+
+| Method | Description |
+|---|---|
+| `balance()` | Applies red-black balancing and returns the supplied tree. |
+| `insert(value)` | Inserts a value while maintaining BST ordering and red-black balance. |
+| `delete(value)` | Deletes a value while maintaining BST ordering and red-black balance. |
+| `find(value)` | Searches for and returns the node containing the value. |
+| `contains(value)` | Checks whether a value exists in the tree. |
+| `__contains__(value)` | Supports the `value in tree` operation. |
+| `minimum()` | Returns the node containing the minimum value. |
+| `maximum()` | Returns the node containing the maximum value. |
+| `min()` | Returns the node containing the minimum value. |
+| `max()` | Returns the node containing the maximum value. |
+
+The implementation also provides root access, tree statistics, and clear
+operations.
+
+### Red-Black Node
+
+`RBNode` defines the red-black node interface and `RBNodeImpl` provides the
+implementation. Each node extends the binary node attributes with:
+
+| Attribute | Description |
+|---|---|
+| `parent` | Reference to the parent node or `None`. |
+| `color` | The node color: `RED` (`0`) or `BLACK` (`1`). |
+
+---
+
 ## Tree Traversal Iterators
 
 `stepps` provides iterators implementing the standard binary tree traversal
@@ -224,7 +302,10 @@ displaying binary trees in the CLI.
 
 ## Binary Node
 
-`BinaryNode[T]` is the generic node type used by the binary tree structures.
+`BinaryNode[T]` defines the generic node interface used by the binary tree
+structures and `BinaryNodeImpl[T]` provides the implementation.
+
+`get_binary_node(value)` in `stepps.nodes` creates and returns a binary node.
 
 Each node provides:
 
@@ -311,6 +392,9 @@ The test suite covers:
 
 - Binary tree operations.
 - Binary search tree operations.
+- AVL balancing, including LL, RR, LR, and RL cases.
+- Red-black tree operations, balancing, node colors, and parent references.
+- Red-black tree invariants after randomized insert and delete operations.
 - Tree traversal iterators.
 - Tree builders.
 - Tree visualization.

{stepps-0.2.0 → stepps-0.4.0}/README.md

@@ -12,8 +12,8 @@
 **Fully typed, modular data structures and algorithms for binary trees in Python.**
 
 `stepps` provides generic binary tree and binary search tree implementations,
-tree traversal iterators, traversal-based tree builders, and tree visualization
-utilities.
+AVL balancing, red-black trees, tree traversal iterators, traversal-based tree
+builders, and tree visualization utilities.
 
 The project follows an interface-and-implementation architecture and uses
 Python generics and static typing throughout its APIs.
@@ -24,6 +24,10 @@ Python generics and static typing throughout its APIs.
 
 - Generic binary tree data structures.
 - Binary search tree implementation.
+- AVL tree balancing with configurable balance factor.
+- Red-black tree implementation.
+- Automatic balancing after AVL and red-black tree insert and delete operations.
+- Binary node creation through `get_binary_node(value)`.
 - Preorder, inorder, postorder, and level-order traversal iterators.
 - Tree builders for preorder, inorder, postorder, and level-order sequences.
 - Binary tree statistics and utility operations.
@@ -73,6 +77,11 @@ the default implementation.
 | `count_leaves()` | Returns the number of leaf nodes. |
 | `count_internal_nodes()` | Returns the number of internal nodes. |
 | `invert_tree()` | Inverts the tree in-place. |
+| `get_root()` | Returns the root node, or `None` if the tree is empty. |
+| `get_left_subtree()` | Returns the left subtree. |
+| `get_right_subtree()` | Returns the right subtree. |
+| `left_rotate()` | Performs a left rotation on the tree. |
+| `right_rotate()` | Performs a right rotation on the tree. |
 
 ---
 
@@ -108,6 +117,75 @@ are greater.
 
 ---
 
+## AVL Tree
+
+`AVL` defines the AVL balancing interface and `AVLImpl` provides the
+implementation.
+
+`AVLImpl` accepts a binary tree through its constructor and provides automatic
+balancing after insert and delete operations. The implementation supports LL,
+RR, LR, and RL balancing cases and a configurable balance factor.
+
+`AVL` and `AVLImpl` are available from `stepps.trees.balanced.avl_tree`.
+
+### AVL Tree Methods
+
+| Method | Description |
+|---|---|
+| `balance()` | Balances and returns the supplied binary tree. |
+| `insert(value)` | Inserts a value into the supplied tree and balances it. |
+| `delete(value)` | Deletes a value from the supplied tree and balances it. |
+
+The remaining binary tree operations are delegated to the supplied tree.
+
+---
+
+## Red-Black Tree
+
+`RedBlack` defines the red-black tree interface and `RedBlackImpl` provides the
+implementation.
+
+The red-black tree maintains BST ordering and uses node colors, rotations, and
+recoloring to maintain balance after insert and delete operations. Duplicate
+values are not inserted.
+
+`RedBlackImpl` accepts a binary tree through its constructor and supports
+creating a red-black tree from an existing binary tree.
+
+`RedBlack` and `RedBlackImpl` are available from
+`stepps.trees.balanced.rb_tree.red_black` and
+`stepps.trees.balanced.rb_tree.red_black_impl`, respectively.
+
+### Red-Black Tree Methods
+
+| Method | Description |
+|---|---|
+| `balance()` | Applies red-black balancing and returns the supplied tree. |
+| `insert(value)` | Inserts a value while maintaining BST ordering and red-black balance. |
+| `delete(value)` | Deletes a value while maintaining BST ordering and red-black balance. |
+| `find(value)` | Searches for and returns the node containing the value. |
+| `contains(value)` | Checks whether a value exists in the tree. |
+| `__contains__(value)` | Supports the `value in tree` operation. |
+| `minimum()` | Returns the node containing the minimum value. |
+| `maximum()` | Returns the node containing the maximum value. |
+| `min()` | Returns the node containing the minimum value. |
+| `max()` | Returns the node containing the maximum value. |
+
+The implementation also provides root access, tree statistics, and clear
+operations.
+
+### Red-Black Node
+
+`RBNode` defines the red-black node interface and `RBNodeImpl` provides the
+implementation. Each node extends the binary node attributes with:
+
+| Attribute | Description |
+|---|---|
+| `parent` | Reference to the parent node or `None`. |
+| `color` | The node color: `RED` (`0`) or `BLACK` (`1`). |
+
+---
+
 ## Tree Traversal Iterators
 
 `stepps` provides iterators implementing the standard binary tree traversal
@@ -194,7 +272,10 @@ displaying binary trees in the CLI.
 
 ## Binary Node
 
-`BinaryNode[T]` is the generic node type used by the binary tree structures.
+`BinaryNode[T]` defines the generic node interface used by the binary tree
+structures and `BinaryNodeImpl[T]` provides the implementation.
+
+`get_binary_node(value)` in `stepps.nodes` creates and returns a binary node.
 
 Each node provides:
 
@@ -281,6 +362,9 @@ The test suite covers:
 
 - Binary tree operations.
 - Binary search tree operations.
+- AVL balancing, including LL, RR, LR, and RL cases.
+- Red-black tree operations, balancing, node colors, and parent references.
+- Red-black tree invariants after randomized insert and delete operations.
 - Tree traversal iterators.
 - Tree builders.
 - Tree visualization.

{stepps-0.2.0 → stepps-0.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "stepps"
-version = "0.2.0"
+version = "0.4.0"
 description = "Useful algorithms in Python"
 requires-python = ">=3.12"
 readme = "README.md"
@@ -52,3 +52,6 @@ issues = "https://github.com/Vaastav-Technologies/py-algor/issues"
 
 [tool.setuptools.packages.find]
 where = ['src']
+
+[tool.pytest.ini_options]
+pythonpath = ["src"]

stepps-0.4.0/src/stepps/comparable.py

@@ -0,0 +1,27 @@
+from typing import Protocol
+
+
+class Comparable(Protocol):
+    """
+    Define the comparison operations required by ordered tree implementations.
+    """
+
+    def __lt__(self, other: object, /) -> bool:
+        """
+        Return whether this value is less than another value.
+
+        :param other: The value to compare with.
+        :return: ``True`` if this value is less than ``other``, otherwise
+            ``False``.
+        """
+        ...
+
+    def __gt__(self, other: object, /) -> bool:
+        """
+        Return whether this value is greater than another value.
+
+        :param other: The value to compare with.
+        :return: ``True`` if this value is greater than ``other``, otherwise
+            ``False``.
+        """
+        ...

stepps-0.4.0/src/stepps/nodes/__init__.py

@@ -0,0 +1,14 @@
+from stepps.nodes.binary_node import BinaryNode
+from stepps.nodes.impl.binary_node_impl import BinaryNodeImpl as _BinaryNodeImpl
+
+__all__ = ["BinaryNode", "get_binary_node"]
+
+
+def get_binary_node[T](value: T) -> BinaryNode[T]:
+    """
+    Create a binary node implementation.
+
+    :param value: The value to store in the node.
+    :return: A binary node implementation.
+    """
+    return _BinaryNodeImpl(value)

stepps-0.4.0/src/stepps/nodes/binary_node.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+from abc import abstractmethod
+from typing import Protocol
+
+
+class BinaryNode[T](Protocol):
+    @property
+    @abstractmethod
+    def value(self) -> T | None: ...
+
+    @property
+    @abstractmethod
+    def right(self) -> BinaryNode[T] | None: ...
+
+    @right.setter
+    @abstractmethod
+    def right(self, node: BinaryNode[T] | None) -> None: ...
+
+    @property
+    @abstractmethod
+    def left(self) -> BinaryNode[T] | None: ...
+
+    @left.setter
+    @abstractmethod
+    def left(self, node: BinaryNode[T] | None) -> None: ...
+    @abstractmethod
+    def is_leaf(self):
+        """
+        Return whether the node has no children.
+
+        :return: ``True`` if the node has no children, otherwise ``False``.
+        """
+
+    @abstractmethod
+    def has_left(self) -> bool:
+        """
+        Return whether the node has a left child.
+
+        :return: ``True`` if a left child exists, otherwise ``False``.
+        """
+
+    @abstractmethod
+    def has_right(self) -> bool:
+        """
+        Return whether the node has a right child.
+
+        :return: ``True`` if a right child exists, otherwise ``False``.
+        """
+
+    @abstractmethod
+    def has_children(self) -> bool:
+        """
+        Return whether the node has at least one child.
+
+        :return: ``True`` if the node has one or more children, otherwise ``False``.
+        """
+
+    @abstractmethod
+    def child_count(self) -> int:
+        """
+        Return the number of children of the node.
+
+        :return: The number of children, either ``0``, ``1``, or ``2``.
+        """

stepps-0.4.0/src/stepps/nodes/impl/__init__.py

@@ -0,0 +1,3 @@
+from stepps.nodes.impl.binary_node_impl import BinaryNodeImpl
+
+__all__ = ["BinaryNodeImpl"]

stepps-0.2.0/src/stepps/nodes/binary_node.py → stepps-0.4.0/src/stepps/nodes/impl/binary_node_impl.py

@@ -1,24 +1,43 @@
 from __future__ import annotations
 
+from stepps.nodes import BinaryNode
 
-class BinaryNode[T]:
+
+class BinaryNodeImpl[T](BinaryNode[T]):
     """
     Represent a node in a binary tree.
 
-    :ivar value: The value stored in the node.
-    :ivar left: The left child of the node, if any.
-    :ivar right: The right child of the node, if any.
     """
 
+    @property
+    def value(self) -> T | None:
+        return self._value
+
+    @property
+    def right(self) -> BinaryNode[T] | None:
+        return self._right
+
+    @right.setter
+    def right(self, node: BinaryNode[T] | None) -> None:
+        self._right = node
+
+    @property
+    def left(self) -> BinaryNode[T] | None:
+        return self._left
+
+    @left.setter
+    def left(self, node: BinaryNode[T] | None) -> None:
+        self._left = node
+
     def __init__(self, value: T) -> None:
         """
         Initialize a binary tree node.
 
         :param value: The value to store in the node.
         """
-        self.value: T = value
-        self.left: BinaryNode[T] | None = None
-        self.right: BinaryNode[T] | None = None
+        self._value: T = value
+        self._right = None
+        self._left = None
 
     def is_leaf(self) -> bool:
         """

stepps-0.4.0/src/stepps/tree_builder/__init__.py

@@ -0,0 +1,21 @@
+from stepps.tree_builder.inorder_tree_builder import InOrderTreeBuilder
+from stepps.tree_builder.inorder_tree_builder_impl import InOrderTreeBuilderImpl
+from stepps.tree_builder.level_order_tree_builder import LevelOrderTreeBuilder
+from stepps.tree_builder.level_order_tree_builder_impl import LevelOrderTreeBuilderImpl
+from stepps.tree_builder.postorder_tree_builder import PostOrderTreeBuilder
+from stepps.tree_builder.postorder_tree_builder_impl import PostOrderTreeBuilderImpl
+from stepps.tree_builder.preorder_tree_builder import PreOrderTreeBuilder
+from stepps.tree_builder.preorder_tree_builder_impl import PreOrderTreeBuilderImpl
+from stepps.tree_builder.tree_builder import TreeBuilder
+
+__all__ = [
+    "InOrderTreeBuilder",
+    "InOrderTreeBuilderImpl",
+    "LevelOrderTreeBuilder",
+    "LevelOrderTreeBuilderImpl",
+    "PostOrderTreeBuilder",
+    "PostOrderTreeBuilderImpl",
+    "PreOrderTreeBuilder",
+    "PreOrderTreeBuilderImpl",
+    "TreeBuilder",
+]

stepps-0.4.0/src/stepps/tree_builder/inorder_tree_builder.py

@@ -0,0 +1,10 @@
+from typing import Protocol
+
+from stepps.tree_builder.tree_builder import TreeBuilder
+
+
+class InOrderTreeBuilder[T](TreeBuilder[T], Protocol):
+    """
+    Define the interface for building a binary tree from a sequence
+    using inorder traversal.
+    """

{stepps-0.2.0/src/stepps/TreeBuilder → stepps-0.4.0/src/stepps/tree_builder}/inorder_tree_builder_impl.py

@@ -2,7 +2,8 @@ from collections.abc import Sequence
 from typing import override
 
 from stepps.nodes import BinaryNode
-from stepps.TreeBuilder.inorder_tree_builder import InOrderTreeBuilder
+from stepps.nodes.impl.binary_node_impl import BinaryNodeImpl
+from stepps.tree_builder.inorder_tree_builder import InOrderTreeBuilder
 
 
 class InOrderTreeBuilderImpl[T](InOrderTreeBuilder[T]):
@@ -44,7 +45,7 @@ class InOrderTreeBuilderImpl[T](InOrderTreeBuilder[T]):
         else:
             mid = (left + right) // 2
 
-        node = BinaryNode(sequence[mid])
+        node = BinaryNodeImpl(sequence[mid])
 
         node.left = self._build(sequence, left, mid - 1)
         node.right = self._build(sequence, mid + 1, right)

stepps-0.4.0/src/stepps/tree_builder/level_order_tree_builder.py

@@ -0,0 +1,10 @@
+from typing import Protocol
+
+from stepps.tree_builder.tree_builder import TreeBuilder
+
+
+class LevelOrderTreeBuilder[T](TreeBuilder[T], Protocol):
+    """
+    Define the interface for building a binary tree from a sequence
+    using level-order traversal.
+    """

{stepps-0.2.0/src/stepps/TreeBuilder → stepps-0.4.0/src/stepps/tree_builder}/level_order_tree_builder_impl.py

@@ -2,8 +2,8 @@ from collections import deque
 from collections.abc import Sequence
 from typing import override
 
-from stepps.nodes import BinaryNode
-from stepps.TreeBuilder.level_order_tree_builder import LevelOrderTreeBuilder
+from stepps.nodes import BinaryNode, get_binary_node
+from stepps.tree_builder.level_order_tree_builder import LevelOrderTreeBuilder
 
 
 class LevelOrderTreeBuilderImpl[T](LevelOrderTreeBuilder[T]):
@@ -26,7 +26,7 @@ class LevelOrderTreeBuilderImpl[T](LevelOrderTreeBuilder[T]):
         if not sequence:
             return None
 
-        root = BinaryNode(sequence[0])
+        root = get_binary_node(sequence[0])
         queue: deque[BinaryNode[T]] = deque([root])
 
         index = 1
@@ -34,12 +34,12 @@ class LevelOrderTreeBuilderImpl[T](LevelOrderTreeBuilder[T]):
         while index < len(sequence):
             parent = queue.popleft()
 
-            parent.left = BinaryNode(sequence[index])
+            parent.left = get_binary_node(sequence[index])
             queue.append(parent.left)
             index += 1
 
             if index < len(sequence):
-                parent.right = BinaryNode(sequence[index])
+                parent.right = get_binary_node(sequence[index])
                 queue.append(parent.right)
                 index += 1
 

stepps-0.4.0/src/stepps/tree_builder/postorder_tree_builder.py

@@ -0,0 +1,10 @@
+from typing import Protocol
+
+from stepps.tree_builder.tree_builder import TreeBuilder
+
+
+class PostOrderTreeBuilder[T](TreeBuilder[T], Protocol):
+    """
+    Define the interface for building a binary tree from a sequence
+    using postorder traversal.
+    """

{stepps-0.2.0/src/stepps/TreeBuilder → stepps-0.4.0/src/stepps/tree_builder}/postorder_tree_builder_impl.py

@@ -2,7 +2,8 @@ from collections.abc import Sequence
 from typing import override
 
 from stepps.nodes import BinaryNode
-from stepps.TreeBuilder.postorder_tree_builder import PostOrderTreeBuilder
+from stepps.nodes.impl.binary_node_impl import BinaryNodeImpl
+from stepps.tree_builder.postorder_tree_builder import PostOrderTreeBuilder
 
 
 class PostOrderTreeBuilderImpl[T](PostOrderTreeBuilder[T]):
@@ -43,7 +44,7 @@ class PostOrderTreeBuilderImpl[T](PostOrderTreeBuilder[T]):
             return None
 
         root_index = start + size - 1
-        root = BinaryNode(sequence[root_index])
+        root = BinaryNodeImpl(sequence[root_index])
 
         remaining = size - 1
         left_size = remaining // 2

stepps-0.4.0/src/stepps/tree_builder/preorder_tree_builder.py

@@ -0,0 +1,10 @@
+from typing import Protocol
+
+from stepps.tree_builder.tree_builder import TreeBuilder
+
+
+class PreOrderTreeBuilder[T](TreeBuilder[T], Protocol):
+    """
+    Define the interface for building a binary tree from a sequence
+    using preorder traversal.
+    """

{stepps-0.2.0/src/stepps/TreeBuilder → stepps-0.4.0/src/stepps/tree_builder}/preorder_tree_builder_impl.py

@@ -1,8 +1,8 @@
 from collections.abc import Sequence
 from typing import override
 
-from stepps.nodes import BinaryNode
-from stepps.TreeBuilder.preorder_tree_builder import PreOrderTreeBuilder
+from stepps.nodes import BinaryNode, get_binary_node
+from stepps.tree_builder.preorder_tree_builder import PreOrderTreeBuilder
 
 
 class PreOrderTreeBuilderImpl[T](PreOrderTreeBuilder[T]):
@@ -41,7 +41,7 @@ class PreOrderTreeBuilderImpl[T](PreOrderTreeBuilder[T]):
         if size <= 0:
             return None
 
-        root = BinaryNode(sequence[index])
+        root = get_binary_node(sequence[index])
 
         left_size = (size - 1) // 2
         right_size = size - 1 - left_size

{stepps-0.2.0/src/stepps/TreeBuilder → stepps-0.4.0/src/stepps/tree_builder}/tree_builder.py

@@ -1,10 +1,11 @@
-from abc import ABC, abstractmethod
+from abc import abstractmethod
 from collections.abc import Sequence
+from typing import Protocol
 
 from stepps.nodes import BinaryNode
 
 
-class TreeBuilder[T](ABC):
+class TreeBuilder[T](Protocol):
     """
     Define the interface for building a binary tree from a sequence.
     """

{stepps-0.2.0 → stepps-0.4.0}/src/stepps/trees/__init__.py

@@ -1,12 +1,13 @@
 from collections.abc import Callable
 from typing import Literal, overload
 
+from stepps.comparable import Comparable
 from stepps.iterators.base_iterator import BinaryTreeIterator
 from stepps.iterators.levelorder import LevelOrderIterator as _LOI
 from stepps.nodes import BinaryNode
 from stepps.trees.binary_tree import BinaryTree
 from stepps.trees.binary_tree_impl import BinaryTreeImpl
-from stepps.trees.bst import BST, Comparable
+from stepps.trees.bst import BST
 from stepps.trees.bst_impl import BSTImpl
 from stepps.trees.tree import Tree
 

stepps-0.4.0/src/stepps/trees/balanced/avl_tree/__init__.py

@@ -0,0 +1,4 @@
+from stepps.trees.balanced.avl_tree.avl import AVL
+from stepps.trees.balanced.avl_tree.avl_impl import AVLImpl
+
+__all__ = ["AVL", "AVLImpl"]

stepps-0.4.0/src/stepps/trees/balanced/avl_tree/avl.py

@@ -0,0 +1,19 @@
+from abc import abstractmethod
+from typing import Protocol
+
+from stepps.trees.binary_tree import BinaryTree
+
+
+class AVL[T](BinaryTree[T], Protocol):
+    """
+    Define the interface for balancing a binary tree.
+    """
+
+    @abstractmethod
+    def balance(self) -> BinaryTree[T]:
+        """
+        Balance the binary tree.
+
+        :return: The balanced binary tree.
+        """
+        ...