Serialize and Deserialize for a binary tree TheAlgorithms#9611

Author: pranjalisingh1201

Diff for: data_structures/binary_tree/serialize_and_deserialize_binary_tree.py

@@ -2,19 +2,19 @@
 """
     The class Node is used to create nodes of the Binary Tree.
     
-    Agrs : Takes value x to create an object of Node with value x. 
+    Agrs : Takes value x to create an object of Node with value x.
     
     Returns : Creates new object of Node.
 """
 class Node:
-    def __init__(self, x: int):
-        self.value = x
+    def __init__(self, data: int)-> None:
+        self.value = data
         self.left = None
         self.right = None
 
 def make_tree() -> Node | None:
     r"""
-    The Tree has : 
+    The Tree has :
 
                                   20
                                 /   \
@@ -33,15 +33,20 @@ def make_tree() -> Node | None:
     """
     Serialize Function takes root as a parameter and returns a String.
     
-    Agrs : 
-            root : Takes root node as a parameter. 
+    Agrs:
+            root : Takes root node as a parameter.
     
-    Returns : A string of preorder traversal of nodes in a tree along with null values of leaf nodes.
+    Returns: A string of preorder traversal of nodes in tree
+             with null values of leaf nodes.
     """
 
 def serialize(root: Node | None) -> str | None:
-    result = []       
-    def depth_first_search(node):
+    """
+    >>> serialize(make_tree())
+    '20,2,N,N,13,4,N,N,5,N,N'
+    """
+    result = []
+    def depth_first_search(node)-> Node | None:
         if not node:
             result.append("N")
             return
@@ -52,19 +57,25 @@ def depth_first_search(node):
     return ",".join(result)
 
     """
-    Deserialize Function takes String as a parameter and returns the root of the tree.
-    
+    Deserialize Function takes String as a parameter and returns root of tree.
+
     Agrs : 
-            String : Takes string of all node values with null values of leaf nodes separated by comma as a parameter. 
+            String : Takes string of all node values with null values
+            of leaf nodes separated by comma as a parameter.
     
     Returns : Root of the tree created after deserialing the string.
     """
 
-def deserialize(data: str | None) -> Node | None:  
+def deserialize(data: str | None) -> Node | None:
+    """
+    >>> root = deserialize("20,2,N,N,13,4,N,N,5,N,N")
+    >>> list(preorder(root))
+    [20, 2, 13, 4, 5]
+    """
     global index
     index = 0
     node_values = data.split(",")
-    def depth_first_search():
+    def depth_first_search() -> Node | None:
         global index
         if node_values[index] == "N":
             index += 1
@@ -78,6 +89,12 @@ def depth_first_search():
 
     #This method is written to traverse the tree created by deserialize method.
 def preorder(root: Node | None) -> Generator[int, None, None]:
+    """
+    >>> list(preorder(make_tree()))
+    [20, 2, 13, 4, 5]
+    >>> list(preorder(None))
+    []
+    """
     if root:
         yield root.value
         yield from  preorder(root.left)
@@ -87,10 +104,10 @@ def main() -> None:  # Main function for testing.
     # Create binary tree.
     root = make_tree()
     serialized_string = serialize(root)
-    print(f"Serialized string : {serialized_string} \n")
+    print(f"Serialized string : {serialized_string}")
     deserialized_root = deserialize(serialized_string)
     print(f"The Deserialized Tree : {list(preorder(deserialized_root))}")
-      
+
 if __name__ == '__main__':
     import doctest
     doctest.testmod()