Implemented static type checking to avl_tree.py

data_structures/binary_tree/avl_tree.py

@@ -10,16 +10,16 @@
 import random
 
 
-class my_queue:
-    def __init__(self):
-        self.data = []
+class MyQueue:
+    def __init__(self) -> None:
+        self.data: list[str, int, float] = []
         self.head = 0
         self.tail = 0
 
     def is_empty(self):
         return self.head == self.tail
 
-    def push(self, data):
+    def push(self, data: int) -> None:
         self.data.append(data)
         self.tail = self.tail + 1
 
@@ -31,18 +31,20 @@ def pop(self):
     def count(self):
         return self.tail - self.head
 
-    def print(self):
-        print(self.data)
-        print("**************")
-        print(self.data[self.head : self.tail])
+    def __str__(self) :
+        return str(self.data)
 
 
-class my_node:
-    def __init__(self, data):
-        self.data = data
-        self.left = None
-        self.right = None
-        self.height = 1
+class Node:
+    """
+    This is the Class Node with a constructor that contains data variable to type data
+    height type in and left, right pointers.
+    """
+    def __init__(self, data: int) -> None:
+        self.data: int = data
+        self.left: Node = None
+        self.right: Node = None
+        self.height: int = 1
 
     def get_data(self):
         return self.data
@@ -56,24 +58,24 @@ def get_right(self):
     def get_height(self):
         return self.height
 
-    def set_data(self, data):
+    def set_data(self, data: int) -> None:
         self.data = data
         return
 
-    def set_left(self, node):
-        self.left = node
+    def set_left(self, node) -> None:
+        self.left: Node = node
         return
 
-    def set_right(self, node):
+    def set_right(self, node) -> None:
         self.right = node
         return
 
-    def set_height(self, height):
-        self.height = height
+    def set_height(self, height: int) -> None:
+        self.height: int = height
         return
 
 
-def get_height(node):
+def get_height(node: Node):
     if node is None:
         return 0
     return node.get_height()
@@ -85,7 +87,7 @@ def my_max(a, b):
     return b
 
 
-def right_rotation(node):
+def right_rotation(node: Node):
     r"""
             A                      B
            / \                    / \
@@ -107,7 +109,7 @@ def right_rotation(node):
     return ret
 
 
-def left_rotation(node):
+def left_rotation(node: Node):
     """
         a mirror symmetry rotation of the left_rotation
     """
@@ -122,7 +124,7 @@ def left_rotation(node):
     return ret
 
 
-def lr_rotation(node):
+def lr_rotation(node: Node):
     r"""
             A              A                    Br
            / \            / \                  /  \
@@ -137,14 +139,14 @@ def lr_rotation(node):
     return right_rotation(node)
 
 
-def rl_rotation(node):
+def rl_rotation(node: Node):
     node.set_right(right_rotation(node.get_right()))
     return left_rotation(node)
 
 
-def insert_node(node, data):
+def insert_node(node: Node, data: int):
     if node is None:
-        return my_node(data)
+        return Node(data)
     if data < node.get_data():
         node.set_left(insert_node(node.get_left(), data))
         if (
@@ -168,19 +170,19 @@ def insert_node(node, data):
     return node
 
 
-def get_rightMost(root):
+def get_rightMost(root: Node):
     while root.get_right() is not None:
         root = root.get_right()
     return root.get_data()
 
 
-def get_leftMost(root):
+def get_leftMost(root: Node):
     while root.get_left() is not None:
         root = root.get_left()
     return root.get_data()
 
 
-def del_node(root, data):
+def del_node(root: Node, data: int):
     if root.get_data() == data:
         if root.get_left() is not None and root.get_right() is not None:
             temp_data = get_leftMost(root.get_right())
@@ -256,18 +258,18 @@ class AVLtree:
     *************************************
     """
 
-    def __init__(self):
-        self.root = None
+    def __init__(self) -> None:
+        self.root: Node = None
 
     def get_height(self):
         #        print("yyy")
         return get_height(self.root)
 
-    def insert(self, data):
+    def insert(self, data: int) -> None:
         print("insert:" + str(data))
         self.root = insert_node(self.root, data)
 
-    def del_node(self, data):
+    def del_node(self, data: int) -> None:
         print("delete:" + str(data))
         if self.root is None:
             print("Tree is empty!")
@@ -276,7 +278,7 @@ def del_node(self, data):
 
     def __str__(self):  # a level traversale, gives a more intuitive look on the tree
         output = ""
-        q = my_queue()
+        q = MyQueue()
         q.push(self.root)
         layer = self.get_height()
         if layer == 0: