From 7b9467399d9d92209eaf7d21ff17695c4aeac3ca Mon Sep 17 00:00:00 2001
From: miguelhx <mhernandez401405@gmail.com>
Date: Wed, 15 Sep 2021 17:47:36 -0700
Subject: [PATCH 1/6] initial file setup for problem

---
 Python/chapter04/p02_minimal_tree/miguelHx.py | 180 ++++++++++++++++++
 1 file changed, 180 insertions(+)
 create mode 100644 Python/chapter04/p02_minimal_tree/miguelHx.py

diff --git a/Python/chapter04/p02_minimal_tree/miguelHx.py b/Python/chapter04/p02_minimal_tree/miguelHx.py
new file mode 100644
index 00000000..4ded0104
--- /dev/null
+++ b/Python/chapter04/p02_minimal_tree/miguelHx.py
@@ -0,0 +1,180 @@
+"""Python Version 3.9.2
+4.1 - Route Between Nodes:
+Given a directed graph, design an algorithm to
+find out whether there is a route between two nodes.
+"""
+import unittest
+
+from collections import deque
+from dataclasses import dataclass
+from typing import List, Deque, Set
+
+
+@dataclass
+class Graph:
+    nodes: 'List[Node]'
+
+    def print_graph(self):
+        for node in self.nodes:
+            node.print_children()
+
+
+@dataclass
+class Node:
+    id: int
+    children: 'List[Node]'
+
+    def add_child(self, *nodes: 'Node'):
+        for node in nodes:
+            self.children.append(node)
+
+    def children_as_str(self) -> str:
+        return ', '.join(str(child.id) for child in self.children)
+
+    def print_children(self):
+        logging.debug('Adjacency list for node %s: %s', self.id, self.children_as_str())
+
+    def __str__(self):
+        return f'Node ({self.id}), children: {self.children_as_str()}'
+
+def bfs_search_exhaustive(root: Node) -> List[int]:
+    """Simple BFS.
+    takes in a root, returns a list
+    of ids of the sequence of visited
+    nodes. Goes through entire graph.
+
+    Args:
+        root (Node): starting node
+
+    Returns:
+        List[int]: List[int]: list of node IDs (i.e. [0, 1, 4])
+    """
+    visited_list: List[int] = [root.id]
+    visited: Set[int] = set([root.id])
+    queue: Deque[Node] = deque([root])
+    while queue:
+        node = queue.popleft()
+        # print(f'Visiting node ({node.id})')
+        for n in node.children:
+            if n.id not in visited:
+                queue.append(n)
+                visited_list.append(n.id)
+                visited.add(n.id)
+    return visited_list
+
+
+def bfs_search_for_dest(root: Node, dest: Node) -> List[int]:
+    """Simple BFS.
+    takes in a root, returns a list
+    of ids of the sequence of visited
+    nodes. Stops at destination node
+
+    Args:
+        root (Node): starting node
+
+    Returns:
+        List[int]: List[int]: list of node IDs (i.e. [0, 1, 4])
+    """
+    visited_list: List[int] = [root.id]
+    visited: Set[int] = set([root.id])
+    queue: Deque[Node] = deque([root])
+    while queue:
+        node = queue.popleft()
+        # print(f'Visiting node ({node.id})')
+        for n in node.children:
+            if n.id not in visited:
+                queue.append(n)
+                visited_list.append(n.id)
+                visited.add(n.id)
+            if n.id == dest.id:
+                # done searching
+                return visited_list
+    return visited_list
+
+def route_between_nodes(src: Node, dest: Node) -> bool:
+    """This function will return true if a path
+    is found between two nodes, false otherwise.
+    The idea is to perform a breadth first search
+    from src to dest. After obtaining a list of
+    nodes visited, we simply check to see if destination
+    node id is in there.
+
+    Runtime Complexity:
+        O(V + E) where V represents the number of
+        nodes in the graph and E represents the number
+        of edges in this graph.
+    Space Complexity:
+        O(V) where V represents the number of existing nodes
+        in the graph.
+
+    Args:
+        src (Node): from node
+        dest (Node): destination node
+
+    Returns:
+        bool: whether a path between src and dest exists
+    """
+    ids_visited: List[int] = bfs_search_for_dest(src, dest)
+    return dest.id in ids_visited
+
+
+class TestRouteBetweenNodes(unittest.TestCase):
+    def test_route_between_nodes(self):
+        n0 = Node(0, [])
+        n1 = Node(1, [])
+        n2 = Node(2, [])
+        n3 = Node(3, [])
+        n4 = Node(4, [])
+        n5 = Node(5, [])
+        n0.add_child(n1, n4, n5)
+        n1.add_child(n3, n4)
+        n2.add_child(n1)
+        n3.add_child(n2, n4)
+        # must remember to reset node visited properties
+        # before each fresh run
+        g = Graph([n0, n1, n2, n3, n4, n5])
+        # There is a route from node 0 to node 2
+        self.assertTrue(route_between_nodes(n0, n2))
+        # No route between node 1 and node 0
+        self.assertFalse(route_between_nodes(n1, n0))
+        # There is a route from node 2 to node 3
+        self.assertTrue(route_between_nodes(n2, n3))
+
+class TestMyGraphSearch(unittest.TestCase):
+
+    def test_basic_graph_creation(self):
+        n0 = Node(0, [])
+        n1 = Node(1, [])
+        n2 = Node(2, [])
+        n3 = Node(3, [])
+        n4 = Node(4, [])
+        n5 = Node(5, [])
+        n6 = Node(6, [])
+        n0.add_child(n1)
+        n1.add_child(n2)
+        n2.add_child(n0, n3)
+        n3.add_child(n2)
+        n4.add_child(n6)
+        n5.add_child(n4)
+        n6.add_child(n5)
+        nodes = [n0, n1, n2, n3, n4, n5, n6]
+        g = Graph(nodes)
+        # g.print_graph()
+
+    def test_basic_breadth_first_search_exhaustive(self):
+        n0 = Node(0, [])
+        n1 = Node(1, [])
+        n2 = Node(2, [])
+        n3 = Node(3, [])
+        n4 = Node(4, [])
+        n5 = Node(5, [])
+        n0.add_child(n1, n4, n5)
+        n1.add_child(n3, n4)
+        n2.add_child(n1)
+        n3.add_child(n2, n4)
+        result: List[int] = bfs_search_exhaustive(n0)
+        self.assertEqual(result, [0, 1, 4, 5, 3, 2])
+
+
+if __name__ == '__main__':
+    unittest.main()

From b3a4ba4eb5f766d801bc5e6ffb2f506b81393a34 Mon Sep 17 00:00:00 2001
From: miguelhx <mhernandez401405@gmail.com>
Date: Sat, 18 Sep 2021 03:36:06 -0700
Subject: [PATCH 2/6] BST data structure implementation

---
 Python/chapter04/p02_minimal_tree/miguelHx.py | 252 +++++++-----------
 1 file changed, 91 insertions(+), 161 deletions(-)

diff --git a/Python/chapter04/p02_minimal_tree/miguelHx.py b/Python/chapter04/p02_minimal_tree/miguelHx.py
index 4ded0104..bb069550 100644
--- a/Python/chapter04/p02_minimal_tree/miguelHx.py
+++ b/Python/chapter04/p02_minimal_tree/miguelHx.py
@@ -1,179 +1,109 @@
 """Python Version 3.9.2
-4.1 - Route Between Nodes:
-Given a directed graph, design an algorithm to
-find out whether there is a route between two nodes.
+4.2 - Minimal Tree:
+Given a sorted (increasing order) array with unique integer elements,
+write an algorithm to create a binary search tree with minimal height.
 """
 import unittest
 
-from collections import deque
+from abc import abstractmethod
 from dataclasses import dataclass
-from typing import List, Deque, Set
+from typing import Generic, TypeVar
+from typing import Optional, Protocol
+from typing import Generator
 
 
-@dataclass
-class Graph:
-    nodes: 'List[Node]'
+T = TypeVar('T', bound='Comparable')
+
+class Comparable(Protocol):
+    @abstractmethod
+    def __lt__(self, other: T) -> bool:
+        pass
 
-    def print_graph(self):
-        for node in self.nodes:
-            node.print_children()
+    @abstractmethod
+    def __gt__(self, other: T) -> bool:
+        pass
 
+    @abstractmethod
+    def __eq__(self, other: T) -> bool:
+        pass
 
 @dataclass
-class Node:
-    id: int
-    children: 'List[Node]'
+class BSTNode:
+    val: int
+    left_child: 'Optional[BSTNode]' = None
+    right_child: 'Optional[BSTNode]' = None
 
-    def add_child(self, *nodes: 'Node'):
-        for node in nodes:
-            self.children.append(node)
+    def __str__(self):
+        return f'Node ({self.id}), Left ID: {self.left_child.id}, Right ID: {self.right_child.id}'
 
-    def children_as_str(self) -> str:
-        return ', '.join(str(child.id) for child in self.children)
+class BSTIterator:
 
-    def print_children(self):
-        logging.debug('Adjacency list for node %s: %s', self.id, self.children_as_str())
+    def __init__(self, root: BSTNode):
+        self.gen = self.in_order_traversal_generator(root)
 
-    def __str__(self):
-        return f'Node ({self.id}), children: {self.children_as_str()}'
-
-def bfs_search_exhaustive(root: Node) -> List[int]:
-    """Simple BFS.
-    takes in a root, returns a list
-    of ids of the sequence of visited
-    nodes. Goes through entire graph.
-
-    Args:
-        root (Node): starting node
-
-    Returns:
-        List[int]: List[int]: list of node IDs (i.e. [0, 1, 4])
-    """
-    visited_list: List[int] = [root.id]
-    visited: Set[int] = set([root.id])
-    queue: Deque[Node] = deque([root])
-    while queue:
-        node = queue.popleft()
-        # print(f'Visiting node ({node.id})')
-        for n in node.children:
-            if n.id not in visited:
-                queue.append(n)
-                visited_list.append(n.id)
-                visited.add(n.id)
-    return visited_list
-
-
-def bfs_search_for_dest(root: Node, dest: Node) -> List[int]:
-    """Simple BFS.
-    takes in a root, returns a list
-    of ids of the sequence of visited
-    nodes. Stops at destination node
-
-    Args:
-        root (Node): starting node
-
-    Returns:
-        List[int]: List[int]: list of node IDs (i.e. [0, 1, 4])
-    """
-    visited_list: List[int] = [root.id]
-    visited: Set[int] = set([root.id])
-    queue: Deque[Node] = deque([root])
-    while queue:
-        node = queue.popleft()
-        # print(f'Visiting node ({node.id})')
-        for n in node.children:
-            if n.id not in visited:
-                queue.append(n)
-                visited_list.append(n.id)
-                visited.add(n.id)
-            if n.id == dest.id:
-                # done searching
-                return visited_list
-    return visited_list
-
-def route_between_nodes(src: Node, dest: Node) -> bool:
-    """This function will return true if a path
-    is found between two nodes, false otherwise.
-    The idea is to perform a breadth first search
-    from src to dest. After obtaining a list of
-    nodes visited, we simply check to see if destination
-    node id is in there.
-
-    Runtime Complexity:
-        O(V + E) where V represents the number of
-        nodes in the graph and E represents the number
-        of edges in this graph.
-    Space Complexity:
-        O(V) where V represents the number of existing nodes
-        in the graph.
-
-    Args:
-        src (Node): from node
-        dest (Node): destination node
-
-    Returns:
-        bool: whether a path between src and dest exists
-    """
-    ids_visited: List[int] = bfs_search_for_dest(src, dest)
-    return dest.id in ids_visited
-
-
-class TestRouteBetweenNodes(unittest.TestCase):
-    def test_route_between_nodes(self):
-        n0 = Node(0, [])
-        n1 = Node(1, [])
-        n2 = Node(2, [])
-        n3 = Node(3, [])
-        n4 = Node(4, [])
-        n5 = Node(5, [])
-        n0.add_child(n1, n4, n5)
-        n1.add_child(n3, n4)
-        n2.add_child(n1)
-        n3.add_child(n2, n4)
-        # must remember to reset node visited properties
-        # before each fresh run
-        g = Graph([n0, n1, n2, n3, n4, n5])
-        # There is a route from node 0 to node 2
-        self.assertTrue(route_between_nodes(n0, n2))
-        # No route between node 1 and node 0
-        self.assertFalse(route_between_nodes(n1, n0))
-        # There is a route from node 2 to node 3
-        self.assertTrue(route_between_nodes(n2, n3))
-
-class TestMyGraphSearch(unittest.TestCase):
-
-    def test_basic_graph_creation(self):
-        n0 = Node(0, [])
-        n1 = Node(1, [])
-        n2 = Node(2, [])
-        n3 = Node(3, [])
-        n4 = Node(4, [])
-        n5 = Node(5, [])
-        n6 = Node(6, [])
-        n0.add_child(n1)
-        n1.add_child(n2)
-        n2.add_child(n0, n3)
-        n3.add_child(n2)
-        n4.add_child(n6)
-        n5.add_child(n4)
-        n6.add_child(n5)
-        nodes = [n0, n1, n2, n3, n4, n5, n6]
-        g = Graph(nodes)
-        # g.print_graph()
-
-    def test_basic_breadth_first_search_exhaustive(self):
-        n0 = Node(0, [])
-        n1 = Node(1, [])
-        n2 = Node(2, [])
-        n3 = Node(3, [])
-        n4 = Node(4, [])
-        n5 = Node(5, [])
-        n0.add_child(n1, n4, n5)
-        n1.add_child(n3, n4)
-        n2.add_child(n1)
-        n3.add_child(n2, n4)
-        result: List[int] = bfs_search_exhaustive(n0)
-        self.assertEqual(result, [0, 1, 4, 5, 3, 2])
+    def in_order_traversal_generator(self, node: BSTNode) -> Generator:
+        if node.left_child:
+            yield from self.in_order_traversal_generator(node.left_child)
+        yield node.val
+        if node.right_child:
+            yield from self.in_order_traversal_generator(node.right_child)
+
+    def __next__(self) -> T:
+        return next(self.gen)
+
+@dataclass
+class BinarySearchTree:
+    root: 'Optional[BSTNode]'
+
+    def insert(self, value: T) -> None:
+        if not self.root:
+            self.root = BSTNode(value)
+        else:
+            self._insert(value, self.root)
+
+    def _insert(self, value: T, curr_node: BSTNode) -> None:
+        if value < curr_node.val:
+            if not curr_node.left_child:
+                # insert here
+                curr_node.left_child = BSTNode(value)
+            else:
+                # otherwise, keep searching left subtree
+                self._insert(value, curr_node.left_child)
+        elif value > curr_node.val:
+            if not curr_node.right_child:
+                # insert here
+                curr_node.right_child = BSTNode(value)
+            else:
+                # otherwise, keep searching right subtree
+                self._insert(value, curr_node.right_child)
+        else:
+            raise ValueError(f'Value {value} already exists in tree.')
+
+    def print_tree(self):
+        if self.root:
+            self._print_tree(self.root)
+
+    def _print_tree(self, curr_node: BSTNode) -> None:
+        if curr_node:
+            self._print_tree(curr_node.left_child)
+            print(curr_node.val)
+            self._print_tree(curr_node.right_child)
+
+    def __iter__(self) -> Generator:
+        return BSTIterator(self.root)
+
+
+class TestBinarySearchTree(unittest.TestCase):
+
+    def test_binary_search_tree_creation(self):
+        bst = BinarySearchTree(None)
+        bst.insert(8)
+        bst.insert(4)
+        bst.insert(10)
+        bst.insert(2)
+        bst.insert(6)
+        bst.insert(20)
+        self.assertEqual(list(bst), [2, 4, 6, 8, 10, 20])
 
 
 if __name__ == '__main__':

From 2a93f2a1e2f5c7c514d9c0b97bf5f72056c4ab92 Mon Sep 17 00:00:00 2001
From: miguelhx <mhernandez401405@gmail.com>
Date: Thu, 23 Sep 2021 09:43:51 -0700
Subject: [PATCH 3/6] Implement minimal tree with a test case

---
 Python/chapter04/p02_minimal_tree/miguelHx.py | 73 ++++++++++++++++++-
 1 file changed, 69 insertions(+), 4 deletions(-)

diff --git a/Python/chapter04/p02_minimal_tree/miguelHx.py b/Python/chapter04/p02_minimal_tree/miguelHx.py
index bb069550..1972888d 100644
--- a/Python/chapter04/p02_minimal_tree/miguelHx.py
+++ b/Python/chapter04/p02_minimal_tree/miguelHx.py
@@ -3,13 +3,14 @@
 Given a sorted (increasing order) array with unique integer elements,
 write an algorithm to create a binary search tree with minimal height.
 """
+import math
 import unittest
 
 from abc import abstractmethod
 from dataclasses import dataclass
 from typing import Generic, TypeVar
 from typing import Optional, Protocol
-from typing import Generator
+from typing import Generator, List
 
 
 T = TypeVar('T', bound='Comparable')
@@ -53,7 +54,7 @@ def __next__(self) -> T:
 
 @dataclass
 class BinarySearchTree:
-    root: 'Optional[BSTNode]'
+    root: 'Optional[BSTNode]' = None
 
     def insert(self, value: T) -> None:
         if not self.root:
@@ -79,6 +80,15 @@ def _insert(self, value: T, curr_node: BSTNode) -> None:
         else:
             raise ValueError(f'Value {value} already exists in tree.')
 
+    def height(self) -> int:
+        return self._height(self.root)
+
+    def _height(self, node: Optional[BSTNode]) -> int:
+        if not node:
+            return 0
+        else:
+            return 1 + max(self._height(node.left_child), self._height(node.right_child))
+
     def print_tree(self):
         if self.root:
             self._print_tree(self.root)
@@ -93,10 +103,43 @@ def __iter__(self) -> Generator:
         return BSTIterator(self.root)
 
 
+
+def minimal_tree(arr: List[T], bst: Optional[BinarySearchTree] = None) -> BinarySearchTree:
+    """Given a sorted (increasing order) array
+    with unique integer elements, write an algorithm
+    to create a binary search tree with minimal height.
+    Basic steps:
+    1. get midpoint
+    2. insert midpoint into bst
+    3. turn left to get left midpoint until no more values
+    4. turn right to insert right midpoint until no more values
+
+    Time Complexity: O(n) where n is size of arr
+    Space Complexity: O(n)
+
+    Args:
+        arr (List[T]): list of unique numbers sorted, in incr. order.
+
+    Returns:
+        BinarySearchTree: A binary search tree with minimal height.
+    """
+    bst = BinarySearchTree() if not bst else bst
+    if not arr:
+        return bst
+    # middle value gets inserted first before going left or right
+    middle = math.floor(len(arr) / 2)
+    bst.insert(arr[middle])
+    left_subarr = arr[:middle]
+    right_subarr = arr[middle+1:]
+    minimal_tree(left_subarr, bst)
+    minimal_tree(right_subarr, bst)
+    return bst
+
+
 class TestBinarySearchTree(unittest.TestCase):
 
-    def test_binary_search_tree_creation(self):
-        bst = BinarySearchTree(None)
+    def test_binary_search_tree_creation_height_3(self):
+        bst = BinarySearchTree()
         bst.insert(8)
         bst.insert(4)
         bst.insert(10)
@@ -104,6 +147,28 @@ def test_binary_search_tree_creation(self):
         bst.insert(6)
         bst.insert(20)
         self.assertEqual(list(bst), [2, 4, 6, 8, 10, 20])
+        self.assertEqual(bst.height(), 3)
+
+    def test_binary_search_tree_creation_height_4(self):
+        bst = BinarySearchTree()
+        bst.insert(8)
+        bst.insert(2)
+        bst.insert(10)
+        bst.insert(4)
+        bst.insert(6)
+        bst.insert(20)
+        self.assertEqual(list(bst), [2, 4, 6, 8, 10, 20])
+        self.assertEqual(bst.height(), 4)
+
+
+class TestMinimalTree(unittest.TestCase):
+
+    def test_minimal_tree(self):
+        # sorted, increasing order array
+        arr = [2, 4, 6, 8, 9, 10, 20]
+        bst = minimal_tree(arr)
+        self.assertEqual(list(bst), [2, 4, 6, 8, 9, 10, 20])
+        self.assertEqual(bst.height(), 3)
 
 
 if __name__ == '__main__':

From d67ea5af6cebde25c6092033d80e731e1d48c517 Mon Sep 17 00:00:00 2001
From: miguelhx <mhernandez401405@gmail.com>
Date: Thu, 23 Sep 2021 09:58:42 -0700
Subject: [PATCH 4/6] Fix some mypy errors

---
 Python/chapter04/p02_minimal_tree/miguelHx.py | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

diff --git a/Python/chapter04/p02_minimal_tree/miguelHx.py b/Python/chapter04/p02_minimal_tree/miguelHx.py
index 1972888d..b91716fc 100644
--- a/Python/chapter04/p02_minimal_tree/miguelHx.py
+++ b/Python/chapter04/p02_minimal_tree/miguelHx.py
@@ -15,7 +15,7 @@
 
 T = TypeVar('T', bound='Comparable')
 
-class Comparable(Protocol):
+class Comparable(Protocol[T]):
     @abstractmethod
     def __lt__(self, other: T) -> bool:
         pass
@@ -25,12 +25,12 @@ def __gt__(self, other: T) -> bool:
         pass
 
     @abstractmethod
-    def __eq__(self, other: T) -> bool:
+    def __eq__(self, other: object) -> bool:
         pass
 
 @dataclass
-class BSTNode:
-    val: int
+class BSTNode(Generic[T]):
+    val: T
     left_child: 'Optional[BSTNode]' = None
     right_child: 'Optional[BSTNode]' = None
 
@@ -39,10 +39,12 @@ def __str__(self):
 
 class BSTIterator:
 
-    def __init__(self, root: BSTNode):
+    def __init__(self, root: Optional[BSTNode]):
         self.gen = self.in_order_traversal_generator(root)
 
-    def in_order_traversal_generator(self, node: BSTNode) -> Generator:
+    def in_order_traversal_generator(self, node: Optional[BSTNode]) -> Generator:
+        if not node:
+            raise StopIteration
         if node.left_child:
             yield from self.in_order_traversal_generator(node.left_child)
         yield node.val
@@ -93,7 +95,7 @@ def print_tree(self):
         if self.root:
             self._print_tree(self.root)
 
-    def _print_tree(self, curr_node: BSTNode) -> None:
+    def _print_tree(self, curr_node: Optional[BSTNode]) -> None:
         if curr_node:
             self._print_tree(curr_node.left_child)
             print(curr_node.val)

From b02cd2b645b05f9f39742ed5c05627c7e87ee50a Mon Sep 17 00:00:00 2001
From: miguelhx <mhernandez401405@gmail.com>
Date: Thu, 23 Sep 2021 10:00:35 -0700
Subject: [PATCH 5/6] Fix iterator return type error

---
 Python/chapter04/p02_minimal_tree/miguelHx.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/Python/chapter04/p02_minimal_tree/miguelHx.py b/Python/chapter04/p02_minimal_tree/miguelHx.py
index b91716fc..3a61b1ca 100644
--- a/Python/chapter04/p02_minimal_tree/miguelHx.py
+++ b/Python/chapter04/p02_minimal_tree/miguelHx.py
@@ -10,7 +10,7 @@
 from dataclasses import dataclass
 from typing import Generic, TypeVar
 from typing import Optional, Protocol
-from typing import Generator, List
+from typing import Generator, List, Iterator
 
 
 T = TypeVar('T', bound='Comparable')
@@ -37,7 +37,7 @@ class BSTNode(Generic[T]):
     def __str__(self):
         return f'Node ({self.id}), Left ID: {self.left_child.id}, Right ID: {self.right_child.id}'
 
-class BSTIterator:
+class BSTIterator(Iterator[T]):
 
     def __init__(self, root: Optional[BSTNode]):
         self.gen = self.in_order_traversal_generator(root)
@@ -101,7 +101,7 @@ def _print_tree(self, curr_node: Optional[BSTNode]) -> None:
             print(curr_node.val)
             self._print_tree(curr_node.right_child)
 
-    def __iter__(self) -> Generator:
+    def __iter__(self) -> BSTIterator:
         return BSTIterator(self.root)
 
 

From df37ef5592fad80e4b90ff05f652b915abff9f3a Mon Sep 17 00:00:00 2001
From: miguelhx <mhernandez401405@gmail.com>
Date: Thu, 23 Sep 2021 10:01:38 -0700
Subject: [PATCH 6/6] fix last mypy error

---
 Python/chapter04/p02_minimal_tree/miguelHx.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Python/chapter04/p02_minimal_tree/miguelHx.py b/Python/chapter04/p02_minimal_tree/miguelHx.py
index 3a61b1ca..f94c7e12 100644
--- a/Python/chapter04/p02_minimal_tree/miguelHx.py
+++ b/Python/chapter04/p02_minimal_tree/miguelHx.py
@@ -15,7 +15,7 @@
 
 T = TypeVar('T', bound='Comparable')
 
-class Comparable(Protocol[T]):
+class Comparable(Protocol):
     @abstractmethod
     def __lt__(self, other: T) -> bool:
         pass