From 90b8c328b744a24fe4c4059ca983163b41c5da32 Mon Sep 17 00:00:00 2001
From: Anshraj Shrivastava <42239140+rajansh87@users.noreply.github.com>
Date: Thu, 15 Oct 2020 01:37:33 +0530
Subject: [PATCH 01/31] add binary_tree_traversals.py to data_structures

I have added some interesting binary tree traversing methods.
---
 .../binary_tree/binary_tree_traversals.py     | 149 ++++++++++++++++++
 1 file changed, 149 insertions(+)
 create mode 100644 data_structures/binary_tree/binary_tree_traversals.py

diff --git a/data_structures/binary_tree/binary_tree_traversals.py b/data_structures/binary_tree/binary_tree_traversals.py
new file mode 100644
index 000000000000..92f142ba7977
--- /dev/null
+++ b/data_structures/binary_tree/binary_tree_traversals.py
@@ -0,0 +1,149 @@
+class Node:
+    """
+    A Node has data variable and pointers toits left and right nodes.
+    """
+    def __init__(self,data):
+        self.left=None
+        self.right=None
+        self.data=data
+
+def preOrder(root):
+    """
+    PreOrder traversal: visit root node then its left subtree followed by right subtree.
+    """
+    if(root!=None):
+        print(root.data,end=" ")
+        preOrder(root.left)
+        preOrder(root.right)
+        
+def postOrder(root):
+    """
+    PostOrder traversal: visit left subtree followed by right subtree and then root node.
+    """
+    if(root!=None):
+        postOrder(root.left)
+        postOrder(root.right)
+        print(root.data,end=" ")
+        
+def inOrder(root):
+    """
+    InOrder traversal: visit its left subtree followed by root node and then right subtree.
+    """
+    if(root!=None):
+        inOrder(root.left)
+        print(root.data,end=" ") 
+        inOrder(root.right)
+
+def Height(root):
+    """
+    Recursive function for calculating height of the binary tree.
+    """
+    if(root==None):
+        return 0
+    leftHeight=Height(root.left)
+    rightHeight=Height(root.right)
+    if leftHeight>rightHeight:
+        return leftHeight+1
+    else:
+        return rightHeight+1
+    
+def levelOrder1(root):
+    """
+    Print whole binary tree in Level Order Traverse.
+    Level Order traverse: Visit nodes of the tree level-by-level.
+    """
+    if root==None:
+        return
+    temp=root
+    que=[temp]
+    while(len(que)>0):
+        print(que[0].data,end=" ")
+        temp=que.pop(0)
+        if temp.left!=None:
+            que.append(temp.left)
+        if temp.right!=None:
+            que.append(temp.right)
+
+def levelOrder2(root,level):
+    """
+    Level-wise traversal:
+    Print all nodes present at the given level of the binary tree.
+    """
+    if root==None:
+        return root
+    if level==1:
+        print(root.data,end=" ")
+    elif level>1:
+        levelOrder2(root.left,level-1)
+        levelOrder2(root.right,level-1)  
+
+def printLeftToRight(root,level):
+    """
+    Print elements on particular level from left to right direction of the binary tree.
+    """
+    if root==None:
+        return
+    if level==1:
+        print(root.data,end=" ")
+    elif level>1:
+        printLeftToRight(root.left,level-1)
+        printLeftToRight(root.right,level-1)
+
+def printRightToLeft(root,level):
+    """
+    Print elements on particular level from right to left direction of the binary tree.
+    """
+    if root==None:
+        return
+    if level==1:
+        print(root.data,end=" ")
+    elif level>1:
+        printRightToLeft(root.right,level-1)
+        printRightToLeft(root.left,level-1)
+    
+def ZigZag(root):
+    """
+    ZigZag traverse: Print node left to right and right to left, alternatively.
+    """
+    flag=0
+    height=Height(root)
+    for h in range(1,height+1):
+        if flag==0:
+            printLeftToRight(root,h)
+            flag=1
+        else:
+            printRightToLeft(root,h)
+            flag=0
+
+def main(): # Main function for testing.
+    """
+    Create binary tree.
+    """
+    root=Node(1)
+    root.left=Node(2)
+    root.right=Node(3)
+    root.left.left=Node(4)
+    root.left.right=Node(5)
+
+    """
+    All Traversals of the binary are as follows:
+    """
+    print("In order Traversal is : ")
+    inOrder(root)
+    print("\nPre order Traversal is : ")
+    preOrder(root)
+    print("\nPost order Traversal is : ")
+    postOrder(root)
+    print("\nHeight of Tree is : ")
+    height=Height(root)
+    print(height)
+    print("\nComplete Level Order Traversal is : ")
+    levelOrder1(root)
+    print("\nLevel-wise order Traversal is : ")
+    for h in range(1,height+1):
+        levelOrder2(root,h)
+    print("\nZigZag order Traversal is : ")
+    ZigZag(root)
+
+if __name__ == "__main__":
+    main()

From 6193d6e1c5feef2b01c9db64700154edf2751cdc Mon Sep 17 00:00:00 2001
From: Anshraj Shrivastava <42239140+rajansh87@users.noreply.github.com>
Date: Thu, 15 Oct 2020 02:14:48 +0530
Subject: [PATCH 02/31] Fixed error

---
 .../binary_tree/binary_tree_traversals.py     | 72 +++++++++----------
 1 file changed, 36 insertions(+), 36 deletions(-)

diff --git a/data_structures/binary_tree/binary_tree_traversals.py b/data_structures/binary_tree/binary_tree_traversals.py
index 92f142ba7977..ad71cc3d7b6c 100644
--- a/data_structures/binary_tree/binary_tree_traversals.py
+++ b/data_structures/binary_tree/binary_tree_traversals.py
@@ -7,47 +7,47 @@ def __init__(self,data):
         self.right=None
         self.data=data
 
-def preOrder(root):
+def preorder(root):
     """
     PreOrder traversal: visit root node then its left subtree followed by right subtree.
     """
     if(root!=None):
         print(root.data,end=" ")
-        preOrder(root.left)
-        preOrder(root.right)
+        preorder(root.left)
+        preorder(root.right)
         
-def postOrder(root):
+def postorder(root):
     """
     PostOrder traversal: visit left subtree followed by right subtree and then root node.
     """
     if(root!=None):
-        postOrder(root.left)
-        postOrder(root.right)
+        postorder(root.left)
+        postorder(root.right)
         print(root.data,end=" ")
         
-def inOrder(root):
+def inorder(root):
     """
     InOrder traversal: visit its left subtree followed by root node and then right subtree.
     """
     if(root!=None):
-        inOrder(root.left)
+        inorder(root.left)
         print(root.data,end=" ") 
-        inOrder(root.right)
+        inorder(root.right)
 
-def Height(root):
+def height(root):
     """
     Recursive function for calculating height of the binary tree.
     """
     if(root==None):
         return 0
-    leftHeight=Height(root.left)
-    rightHeight=Height(root.right)
+    leftHeight=height(root.left)
+    rightHeight=height(root.right)
     if leftHeight>rightHeight:
         return leftHeight+1
     else:
         return rightHeight+1
     
-def levelOrder1(root):
+def levelorder1(root):
     """
     Print whole binary tree in Level Order Traverse.
     Level Order traverse: Visit nodes of the tree level-by-level.
@@ -64,7 +64,7 @@ def levelOrder1(root):
         if temp.right!=None:
             que.append(temp.right)
 
-def levelOrder2(root,level):
+def levelorder2(root,level):
     """
     Level-wise traversal:
     Print all nodes present at the given level of the binary tree.
@@ -74,10 +74,10 @@ def levelOrder2(root,level):
     if level==1:
         print(root.data,end=" ")
     elif level>1:
-        levelOrder2(root.left,level-1)
-        levelOrder2(root.right,level-1)  
+        levelorder2(root.left,level-1)
+        levelorder2(root.right,level-1)  
 
-def printLeftToRight(root,level):
+def printlefttoright(root,level):
     """
     Print elements on particular level from left to right direction of the binary tree.
     """
@@ -86,10 +86,10 @@ def printLeftToRight(root,level):
     if level==1:
         print(root.data,end=" ")
     elif level>1:
-        printLeftToRight(root.left,level-1)
-        printLeftToRight(root.right,level-1)
+        printlefttoright(root.left,level-1)
+        printlefttoright(root.right,level-1)
 
-def printRightToLeft(root,level):
+def printrighttoleft(root,level):
     """
     Print elements on particular level from right to left direction of the binary tree.
     """
@@ -98,21 +98,21 @@ def printRightToLeft(root,level):
     if level==1:
         print(root.data,end=" ")
     elif level>1:
-        printRightToLeft(root.right,level-1)
-        printRightToLeft(root.left,level-1)
+        printrighttoleft(root.right,level-1)
+        printrighttoleft(root.left,level-1)
     
-def ZigZag(root):
+def zigzag(root):
     """
     ZigZag traverse: Print node left to right and right to left, alternatively.
     """
     flag=0
-    height=Height(root)
-    for h in range(1,height+1):
+    height_tree=height(root)
+    for h in range(1,height_tree+1):
         if flag==0:
-            printLeftToRight(root,h)
+            printlefttoright(root,h)
             flag=1
         else:
-            printRightToLeft(root,h)
+            printrighttoleft(root,h)
             flag=0
 
 def main(): # Main function for testing.
@@ -129,21 +129,21 @@ def main(): # Main function for testing.
     All Traversals of the binary are as follows:
     """
     print("In order Traversal is : ")
-    inOrder(root)
+    inorder(root)
     print("\nPre order Traversal is : ")
-    preOrder(root)
+    preorder(root)
     print("\nPost order Traversal is : ")
-    postOrder(root)
+    postorder(root)
     print("\nHeight of Tree is : ")
-    height=Height(root)
-    print(height)
+    height_tree=height(root)
+    print(height_tree)
     print("\nComplete Level Order Traversal is : ")
-    levelOrder1(root)
+    levelorder1(root)
     print("\nLevel-wise order Traversal is : ")
-    for h in range(1,height+1):
-        levelOrder2(root,h)
+    for h in range(1,height_tree+1):
+        levelorder2(root,h)
     print("\nZigZag order Traversal is : ")
-    ZigZag(root)
+    zigzag(root)
 
 if __name__ == "__main__":
     main()

From 5b6f8d848fa0e70a1c6e282c92ad01ace078b8e2 Mon Sep 17 00:00:00 2001
From: Anshraj Shrivastava <42239140+rajansh87@users.noreply.github.com>
Date: Thu, 15 Oct 2020 02:31:12 +0530
Subject: [PATCH 03/31] Update
 data_structures/binary_tree/binary_tree_traversals.py

Co-authored-by: Christian Clauss <cclauss@me.com>
---
 data_structures/binary_tree/binary_tree_traversals.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/data_structures/binary_tree/binary_tree_traversals.py b/data_structures/binary_tree/binary_tree_traversals.py
index ad71cc3d7b6c..2bdc466277ae 100644
--- a/data_structures/binary_tree/binary_tree_traversals.py
+++ b/data_structures/binary_tree/binary_tree_traversals.py
@@ -69,7 +69,7 @@ def levelorder2(root,level):
     Level-wise traversal:
     Print all nodes present at the given level of the binary tree.
     """
-    if root==None:
+    if not root:
         return root
     if level==1:
         print(root.data,end=" ")

From f15601cf46fd28f4428a3292a343482ffe9f05e9 Mon Sep 17 00:00:00 2001
From: Anshraj Shrivastava <42239140+rajansh87@users.noreply.github.com>
Date: Thu, 15 Oct 2020 02:35:58 +0530
Subject: [PATCH 04/31] Update binary_tree_traversals.py

---
 .../binary_tree/binary_tree_traversals.py     | 20 +++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/data_structures/binary_tree/binary_tree_traversals.py b/data_structures/binary_tree/binary_tree_traversals.py
index 2bdc466277ae..ef33abfd405d 100644
--- a/data_structures/binary_tree/binary_tree_traversals.py
+++ b/data_structures/binary_tree/binary_tree_traversals.py
@@ -11,7 +11,7 @@ def preorder(root):
     """
     PreOrder traversal: visit root node then its left subtree followed by right subtree.
     """
-    if(root!=None):
+    if root:
         print(root.data,end=" ")
         preorder(root.left)
         preorder(root.right)
@@ -20,7 +20,7 @@ def postorder(root):
     """
     PostOrder traversal: visit left subtree followed by right subtree and then root node.
     """
-    if(root!=None):
+    if root:
         postorder(root.left)
         postorder(root.right)
         print(root.data,end=" ")
@@ -29,7 +29,7 @@ def inorder(root):
     """
     InOrder traversal: visit its left subtree followed by root node and then right subtree.
     """
-    if(root!=None):
+    if root:
         inorder(root.left)
         print(root.data,end=" ") 
         inorder(root.right)
@@ -38,7 +38,7 @@ def height(root):
     """
     Recursive function for calculating height of the binary tree.
     """
-    if(root==None):
+    if not root:
         return 0
     leftHeight=height(root.left)
     rightHeight=height(root.right)
@@ -52,16 +52,16 @@ def levelorder1(root):
     Print whole binary tree in Level Order Traverse.
     Level Order traverse: Visit nodes of the tree level-by-level.
     """
-    if root==None:
+    if not root:
         return
     temp=root
     que=[temp]
-    while(len(que)>0):
+    while len(que)>0:
         print(que[0].data,end=" ")
         temp=que.pop(0)
-        if temp.left!=None:
+        if temp.left:
             que.append(temp.left)
-        if temp.right!=None:
+        if temp.right:
             que.append(temp.right)
 
 def levelorder2(root,level):
@@ -81,7 +81,7 @@ def printlefttoright(root,level):
     """
     Print elements on particular level from left to right direction of the binary tree.
     """
-    if root==None:
+    if not root:
         return
     if level==1:
         print(root.data,end=" ")
@@ -93,7 +93,7 @@ def printrighttoleft(root,level):
     """
     Print elements on particular level from right to left direction of the binary tree.
     """
-    if root==None:
+    if not root:
         return
     if level==1:
         print(root.data,end=" ")

From b5285c1ccaf2bdc593dfc4fda26fc952d63bcd49 Mon Sep 17 00:00:00 2001
From: Anshraj Shrivastava <42239140+rajansh87@users.noreply.github.com>
Date: Thu, 15 Oct 2020 02:43:02 +0530
Subject: [PATCH 05/31] Update binary_tree_traversals.py

---
 .../binary_tree/binary_tree_traversals.py     | 26 +++++++++----------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/data_structures/binary_tree/binary_tree_traversals.py b/data_structures/binary_tree/binary_tree_traversals.py
index ef33abfd405d..436343388ec2 100644
--- a/data_structures/binary_tree/binary_tree_traversals.py
+++ b/data_structures/binary_tree/binary_tree_traversals.py
@@ -40,12 +40,12 @@ def height(root):
     """
     if not root:
         return 0
-    leftHeight=height(root.left)
-    rightHeight=height(root.right)
-    if leftHeight>rightHeight:
-        return leftHeight+1
+    left_Height=height(root.left)
+    right_Height=height(root.right)
+    if left_Height>right_Height:
+        return left_Height+1
     else:
-        return rightHeight+1
+        return right_Height+1
     
 def levelorder1(root):
     """
@@ -77,7 +77,7 @@ def levelorder2(root,level):
         levelorder2(root.left,level-1)
         levelorder2(root.right,level-1)  
 
-def printlefttoright(root,level):
+def print_left_to_right(root,level):
     """
     Print elements on particular level from left to right direction of the binary tree.
     """
@@ -86,10 +86,10 @@ def printlefttoright(root,level):
     if level==1:
         print(root.data,end=" ")
     elif level>1:
-        printlefttoright(root.left,level-1)
-        printlefttoright(root.right,level-1)
+        print_left_to_right(root.left,level-1)
+        print_left_to_right(root.right,level-1)
 
-def printrighttoleft(root,level):
+def print_right_to_left(root,level):
     """
     Print elements on particular level from right to left direction of the binary tree.
     """
@@ -98,8 +98,8 @@ def printrighttoleft(root,level):
     if level==1:
         print(root.data,end=" ")
     elif level>1:
-        printrighttoleft(root.right,level-1)
-        printrighttoleft(root.left,level-1)
+        print_right_to_left(root.right,level-1)
+        print_right_to_left(root.left,level-1)
     
 def zigzag(root):
     """
@@ -109,10 +109,10 @@ def zigzag(root):
     height_tree=height(root)
     for h in range(1,height_tree+1):
         if flag==0:
-            printlefttoright(root,h)
+            print_left_to_right(root,h)
             flag=1
         else:
-            printrighttoleft(root,h)
+            print_right_to_left(root,h)
             flag=0
 
 def main(): # Main function for testing.

From 2c9050ce19bcd492236015004a1c1141dc4ac4f7 Mon Sep 17 00:00:00 2001
From: Anshraj Shrivastava <42239140+rajansh87@users.noreply.github.com>
Date: Thu, 15 Oct 2020 02:55:18 +0530
Subject: [PATCH 06/31] Update binary_tree_traversals.py

---
 .../binary_tree/binary_tree_traversals.py     | 124 ++++++++++--------
 1 file changed, 68 insertions(+), 56 deletions(-)

diff --git a/data_structures/binary_tree/binary_tree_traversals.py b/data_structures/binary_tree/binary_tree_traversals.py
index 436343388ec2..2018246f78a2 100644
--- a/data_structures/binary_tree/binary_tree_traversals.py
+++ b/data_structures/binary_tree/binary_tree_traversals.py
@@ -2,20 +2,23 @@ class Node:
     """
     A Node has data variable and pointers toits left and right nodes.
     """
-    def __init__(self,data):
-        self.left=None
-        self.right=None
-        self.data=data
+
+    def __init__(self, data):
+        self.left = None
+        self.right = None
+        self.data = data
+
 
 def preorder(root):
     """
     PreOrder traversal: visit root node then its left subtree followed by right subtree.
     """
     if root:
-        print(root.data,end=" ")
+        print(root.data, end=" ")
         preorder(root.left)
         preorder(root.right)
-        
+
+
 def postorder(root):
     """
     PostOrder traversal: visit left subtree followed by right subtree and then root node.
@@ -23,30 +26,33 @@ def postorder(root):
     if root:
         postorder(root.left)
         postorder(root.right)
-        print(root.data,end=" ")
-        
+        print(root.data, end=" ")
+
+
 def inorder(root):
     """
     InOrder traversal: visit its left subtree followed by root node and then right subtree.
     """
     if root:
         inorder(root.left)
-        print(root.data,end=" ") 
+        print(root.data, end=" ")
         inorder(root.right)
 
+
 def height(root):
     """
     Recursive function for calculating height of the binary tree.
     """
     if not root:
         return 0
-    left_Height=height(root.left)
-    right_Height=height(root.right)
-    if left_Height>right_Height:
-        return left_Height+1
+    left_Height = height(root.left)
+    right_Height = height(root.right)
+    if left_Height > right_Height:
+        return left_Height + 1
     else:
-        return right_Height+1
-    
+        return right_Height + 1
+
+
 def levelorder1(root):
     """
     Print whole binary tree in Level Order Traverse.
@@ -54,76 +60,81 @@ def levelorder1(root):
     """
     if not root:
         return
-    temp=root
-    que=[temp]
-    while len(que)>0:
-        print(que[0].data,end=" ")
-        temp=que.pop(0)
+    temp = root
+    que = [temp]
+    while len(que) > 0:
+        print(que[0].data, end=" ")
+        temp = que.pop(0)
         if temp.left:
             que.append(temp.left)
         if temp.right:
             que.append(temp.right)
 
-def levelorder2(root,level):
+
+def levelorder2(root, level):
     """
     Level-wise traversal:
     Print all nodes present at the given level of the binary tree.
     """
     if not root:
         return root
-    if level==1:
-        print(root.data,end=" ")
-    elif level>1:
-        levelorder2(root.left,level-1)
-        levelorder2(root.right,level-1)  
+    if level == 1:
+        print(root.data, end=" ")
+    elif level > 1:
+        levelorder2(root.left, level - 1)
+        levelorder2(root.right, level - 1)
 
-def print_left_to_right(root,level):
+
+def print_left_to_right(root, level):
     """
     Print elements on particular level from left to right direction of the binary tree.
     """
     if not root:
         return
-    if level==1:
-        print(root.data,end=" ")
-    elif level>1:
-        print_left_to_right(root.left,level-1)
-        print_left_to_right(root.right,level-1)
+    if level == 1:
+        print(root.data, end=" ")
+    elif level > 1:
+        print_left_to_right(root.left, level - 1)
+        print_left_to_right(root.right, level - 1)
+
 
-def print_right_to_left(root,level):
+def print_right_to_left(root, level):
     """
     Print elements on particular level from right to left direction of the binary tree.
     """
     if not root:
         return
-    if level==1:
-        print(root.data,end=" ")
-    elif level>1:
-        print_right_to_left(root.right,level-1)
-        print_right_to_left(root.left,level-1)
-    
+    if level == 1:
+        print(root.data, end=" ")
+    elif level > 1:
+        print_right_to_left(root.right, level - 1)
+        print_right_to_left(root.left, level - 1)
+
+
 def zigzag(root):
     """
     ZigZag traverse: Print node left to right and right to left, alternatively.
     """
-    flag=0
-    height_tree=height(root)
-    for h in range(1,height_tree+1):
-        if flag==0:
-            print_left_to_right(root,h)
-            flag=1
+    flag = 0
+    height_tree = height(root)
+    for h in range(1, height_tree + 1):
+        if flag == 0:
+            print_left_to_right(root, h)
+            flag = 1
         else:
-            print_right_to_left(root,h)
-            flag=0
+            print_right_to_left(root, h)
+            flag = 0
 
-def main(): # Main function for testing.
+
+def main():  # Main function for testing.
     """
     Create binary tree.
     """
-    root=Node(1)
-    root.left=Node(2)
-    root.right=Node(3)
-    root.left.left=Node(4)
-    root.left.right=Node(5)
+    root = Node(1)
+    root.left = Node(2)
+    root.right = Node(3)
+    root.left.left = Node(4)
+    root.left.right = Node(5)
 
     """
     All Traversals of the binary are as follows:
@@ -135,15 +146,16 @@ def main(): # Main function for testing.
     print("\nPost order Traversal is : ")
     postorder(root)
     print("\nHeight of Tree is : ")
-    height_tree=height(root)
+    height_tree = height(root)
     print(height_tree)
     print("\nComplete Level Order Traversal is : ")
     levelorder1(root)
     print("\nLevel-wise order Traversal is : ")
-    for h in range(1,height_tree+1):
-        levelorder2(root,h)
+    for h in range(1, height_tree + 1):
+        levelorder2(root, h)
     print("\nZigZag order Traversal is : ")
     zigzag(root)
 
+
 if __name__ == "__main__":
     main()

From 41405220e38891e53e3e7d3d84c0a35b329a705e Mon Sep 17 00:00:00 2001
From: Anshraj Shrivastava <42239140+rajansh87@users.noreply.github.com>
Date: Thu, 15 Oct 2020 03:19:58 +0530
Subject: [PATCH 07/31] Update
 data_structures/binary_tree/binary_tree_traversals.py

Co-authored-by: Christian Clauss <cclauss@me.com>
---
 .../binary_tree/binary_tree_traversals.py            | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/data_structures/binary_tree/binary_tree_traversals.py b/data_structures/binary_tree/binary_tree_traversals.py
index 2018246f78a2..8c8254738fd6 100644
--- a/data_structures/binary_tree/binary_tree_traversals.py
+++ b/data_structures/binary_tree/binary_tree_traversals.py
@@ -9,9 +9,21 @@ def __init__(self, data):
         self.data = data
 
 
+def make_tree() -> Node:
+    root = Node(1)
+    root.left = Node(2)
+    root.right = Node(3)
+    root.left.left = Node(4)
+    root.left.right = Node(5)
+    return root
+
+
 def preorder(root):
     """
     PreOrder traversal: visit root node then its left subtree followed by right subtree.
+
+    >>> preorder(make_tree())
+    4 2 5 1 3
     """
     if root:
         print(root.data, end=" ")

From 85738c3c66973f0a4c6a3fb785c264b954bd318c Mon Sep 17 00:00:00 2001
From: Anshraj Shrivastava <42239140+rajansh87@users.noreply.github.com>
Date: Thu, 15 Oct 2020 03:24:08 +0530
Subject: [PATCH 08/31] Update binary_tree_traversals.py

---
 .../binary_tree/binary_tree_traversals.py     | 30 ++++++++++++-------
 1 file changed, 20 insertions(+), 10 deletions(-)

diff --git a/data_structures/binary_tree/binary_tree_traversals.py b/data_structures/binary_tree/binary_tree_traversals.py
index 8c8254738fd6..0d0aa36fdffc 100644
--- a/data_structures/binary_tree/binary_tree_traversals.py
+++ b/data_structures/binary_tree/binary_tree_traversals.py
@@ -20,8 +20,8 @@ def make_tree() -> Node:
 
 def preorder(root):
     """
-    PreOrder traversal: visit root node then its left subtree followed by right subtree.
-
+    PreOrder traversal:visit root then its 
+    leftsubtree followed by right subtree.
     >>> preorder(make_tree())
     4 2 5 1 3
     """
@@ -33,7 +33,9 @@ def preorder(root):
 
 def postorder(root):
     """
-    PostOrder traversal: visit left subtree followed by right subtree and then root node.
+    PostOrder traversal:visit leftsubtree 
+    followed by right subtree and 
+    then root node.
     """
     if root:
         postorder(root.left)
@@ -43,7 +45,9 @@ def postorder(root):
 
 def inorder(root):
     """
-    InOrder traversal: visit its left subtree followed by root node and then right subtree.
+    InOrder traversal: visit leftsubtree 
+    followed by root node and 
+    then right subtree.
     """
     if root:
         inorder(root.left)
@@ -53,7 +57,8 @@ def inorder(root):
 
 def height(root):
     """
-    Recursive function for calculating height of the binary tree.
+    Recursive function for calculating 
+    height of the binary tree.
     """
     if not root:
         return 0
@@ -68,7 +73,8 @@ def height(root):
 def levelorder1(root):
     """
     Print whole binary tree in Level Order Traverse.
-    Level Order traverse: Visit nodes of the tree level-by-level.
+    Level Order traverse: Visit nodes of 
+    the tree level-by-level.
     """
     if not root:
         return
@@ -86,7 +92,8 @@ def levelorder1(root):
 def levelorder2(root, level):
     """
     Level-wise traversal:
-    Print all nodes present at the given level of the binary tree.
+    Print all nodes present at the 
+    given level of the binary tree.
     """
     if not root:
         return root
@@ -99,7 +106,8 @@ def levelorder2(root, level):
 
 def print_left_to_right(root, level):
     """
-    Print elements on particular level from left to right direction of the binary tree.
+    Print elements on particular level from 
+    left to right direction of the binary tree.
     """
     if not root:
         return
@@ -112,7 +120,8 @@ def print_left_to_right(root, level):
 
 def print_right_to_left(root, level):
     """
-    Print elements on particular level from right to left direction of the binary tree.
+    Print elements on particular level from 
+    right to left direction of the binary tree.
     """
     if not root:
         return
@@ -125,7 +134,8 @@ def print_right_to_left(root, level):
 
 def zigzag(root):
     """
-    ZigZag traverse: Print node left to right and right to left, alternatively.
+    ZigZag traverse: Print node left to right
+    and right to left, alternatively.
     """
     flag = 0
     height_tree = height(root)

From 27d854fceb37ee974e2c070c79ae43f1f6eb7af2 Mon Sep 17 00:00:00 2001
From: Anshraj Shrivastava <42239140+rajansh87@users.noreply.github.com>
Date: Thu, 15 Oct 2020 03:25:27 +0530
Subject: [PATCH 09/31] Update binary_tree_traversals.py

---
 data_structures/binary_tree/binary_tree_traversals.py | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/data_structures/binary_tree/binary_tree_traversals.py b/data_structures/binary_tree/binary_tree_traversals.py
index 0d0aa36fdffc..2199f6a3ea40 100644
--- a/data_structures/binary_tree/binary_tree_traversals.py
+++ b/data_structures/binary_tree/binary_tree_traversals.py
@@ -152,11 +152,7 @@ def main():  # Main function for testing.
     """
     Create binary tree.
     """
-    root = Node(1)
-    root.left = Node(2)
-    root.right = Node(3)
-    root.left.left = Node(4)
-    root.left.right = Node(5)
+    make_tree()
 
     """
     All Traversals of the binary are as follows:

From 5f4e7ce6e97bd9bfd566da08bf9918a191431560 Mon Sep 17 00:00:00 2001
From: Anshraj Shrivastava <42239140+rajansh87@users.noreply.github.com>
Date: Thu, 15 Oct 2020 03:28:03 +0530
Subject: [PATCH 10/31] Update binary_tree_traversals.py

---
 .../binary_tree/binary_tree_traversals.py     | 45 +++++++++++--------
 1 file changed, 27 insertions(+), 18 deletions(-)

diff --git a/data_structures/binary_tree/binary_tree_traversals.py b/data_structures/binary_tree/binary_tree_traversals.py
index 2199f6a3ea40..bef78213d115 100644
--- a/data_structures/binary_tree/binary_tree_traversals.py
+++ b/data_structures/binary_tree/binary_tree_traversals.py
@@ -1,6 +1,7 @@
 class Node:
     """
-    A Node has data variable and pointers toits left and right nodes.
+    A Node has data variable and pointers 
+    to its left and right nodes.
     """
 
     def __init__(self, data):
@@ -20,8 +21,9 @@ def make_tree() -> Node:
 
 def preorder(root):
     """
-    PreOrder traversal:visit root then its 
-    leftsubtree followed by right subtree.
+    PreOrder traversal: visit root node 
+    then its left subtree followed 
+    by right subtree.
     >>> preorder(make_tree())
     4 2 5 1 3
     """
@@ -33,9 +35,9 @@ def preorder(root):
 
 def postorder(root):
     """
-    PostOrder traversal:visit leftsubtree 
-    followed by right subtree and 
-    then root node.
+    PostOrder traversal: visit left subtree
+    followed by right subtree
+    and then root node.
     """
     if root:
         postorder(root.left)
@@ -45,8 +47,8 @@ def postorder(root):
 
 def inorder(root):
     """
-    InOrder traversal: visit leftsubtree 
-    followed by root node and 
+    InOrder traversal: visit its leftsubtree
+    followed by root node and
     then right subtree.
     """
     if root:
@@ -57,7 +59,7 @@ def inorder(root):
 
 def height(root):
     """
-    Recursive function for calculating 
+    Recursive function for calculating
     height of the binary tree.
     """
     if not root:
@@ -73,8 +75,8 @@ def height(root):
 def levelorder1(root):
     """
     Print whole binary tree in Level Order Traverse.
-    Level Order traverse: Visit nodes of 
-    the tree level-by-level.
+    Level Order traverse: Visit nodes 
+    of the tree level-by-level.
     """
     if not root:
         return
@@ -106,8 +108,9 @@ def levelorder2(root, level):
 
 def print_left_to_right(root, level):
     """
-    Print elements on particular level from 
-    left to right direction of the binary tree.
+    Print elements on particular level 
+    from left to right direction of 
+    the binary tree.
     """
     if not root:
         return
@@ -120,8 +123,9 @@ def print_left_to_right(root, level):
 
 def print_right_to_left(root, level):
     """
-    Print elements on particular level from 
-    right to left direction of the binary tree.
+    Print elements on particular level 
+    from right to left direction of 
+    the binary tree.
     """
     if not root:
         return
@@ -134,8 +138,9 @@ def print_right_to_left(root, level):
 
 def zigzag(root):
     """
-    ZigZag traverse: Print node left to right
-    and right to left, alternatively.
+    ZigZag traverse: Print node
+    left to right and
+    right to left, alternatively.
     """
     flag = 0
     height_tree = height(root)
@@ -152,7 +157,11 @@ def main():  # Main function for testing.
     """
     Create binary tree.
     """
-    make_tree()
+    root = Node(1)
+    root.left = Node(2)
+    root.right = Node(3)
+    root.left.left = Node(4)
+    root.left.right = Node(5)
 
     """
     All Traversals of the binary are as follows:

From 854fbd533c811f83e8b8a976a67c5425a3c5ab7e Mon Sep 17 00:00:00 2001
From: Anshraj Shrivastava <42239140+rajansh87@users.noreply.github.com>
Date: Thu, 15 Oct 2020 12:34:56 +0530
Subject: [PATCH 11/31] Update binary_tree_traversals.py

---
 data_structures/binary_tree/binary_tree_traversals.py | 2 --
 1 file changed, 2 deletions(-)

diff --git a/data_structures/binary_tree/binary_tree_traversals.py b/data_structures/binary_tree/binary_tree_traversals.py
index bef78213d115..250ba74f2070 100644
--- a/data_structures/binary_tree/binary_tree_traversals.py
+++ b/data_structures/binary_tree/binary_tree_traversals.py
@@ -24,8 +24,6 @@ def preorder(root):
     PreOrder traversal: visit root node 
     then its left subtree followed 
     by right subtree.
-    >>> preorder(make_tree())
-    4 2 5 1 3
     """
     if root:
         print(root.data, end=" ")

From c0dc50d76b83c8692e9e8aaeddcb0551bf6ce348 Mon Sep 17 00:00:00 2001
From: Anshraj Shrivastava <42239140+rajansh87@users.noreply.github.com>
Date: Thu, 15 Oct 2020 12:39:18 +0530
Subject: [PATCH 12/31] Update binary_tree_traversals.py

---
 data_structures/binary_tree/binary_tree_traversals.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/data_structures/binary_tree/binary_tree_traversals.py b/data_structures/binary_tree/binary_tree_traversals.py
index 250ba74f2070..2502925dca9d 100644
--- a/data_structures/binary_tree/binary_tree_traversals.py
+++ b/data_structures/binary_tree/binary_tree_traversals.py
@@ -183,4 +183,5 @@ def main():  # Main function for testing.
 
 
 if __name__ == "__main__":
-    main()
+    import doctest
+    doctest.testmod()

From 48e97aa0df3b69ac2e74b5ddfb5d86cb15491d34 Mon Sep 17 00:00:00 2001
From: Anshraj Shrivastava <42239140+rajansh87@users.noreply.github.com>
Date: Thu, 15 Oct 2020 12:55:42 +0530
Subject: [PATCH 13/31] Update binary_tree_traversals.py

---
 .../binary_tree/binary_tree_traversals.py     | 20 ++++++++++---------
 1 file changed, 11 insertions(+), 9 deletions(-)

diff --git a/data_structures/binary_tree/binary_tree_traversals.py b/data_structures/binary_tree/binary_tree_traversals.py
index 2502925dca9d..b27aee724521 100644
--- a/data_structures/binary_tree/binary_tree_traversals.py
+++ b/data_structures/binary_tree/binary_tree_traversals.py
@@ -1,6 +1,6 @@
 class Node:
     """
-    A Node has data variable and pointers 
+    A Node has data variable and pointers
     to its left and right nodes.
     """
 
@@ -21,8 +21,8 @@ def make_tree() -> Node:
 
 def preorder(root):
     """
-    PreOrder traversal: visit root node 
-    then its left subtree followed 
+    PreOrder traversal: visit root node
+    then its left subtree followed
     by right subtree.
     """
     if root:
@@ -73,7 +73,7 @@ def height(root):
 def levelorder1(root):
     """
     Print whole binary tree in Level Order Traverse.
-    Level Order traverse: Visit nodes 
+    Level Order traverse: Visit nodes
     of the tree level-by-level.
     """
     if not root:
@@ -92,7 +92,7 @@ def levelorder1(root):
 def levelorder2(root, level):
     """
     Level-wise traversal:
-    Print all nodes present at the 
+    Print all nodes present at the
     given level of the binary tree.
     """
     if not root:
@@ -106,8 +106,8 @@ def levelorder2(root, level):
 
 def print_left_to_right(root, level):
     """
-    Print elements on particular level 
-    from left to right direction of 
+    Print elements on particular level
+    from left to right direction of
     the binary tree.
     """
     if not root:
@@ -121,8 +121,8 @@ def print_left_to_right(root, level):
 
 def print_right_to_left(root, level):
     """
-    Print elements on particular level 
-    from right to left direction of 
+    Print elements on particular level
+    from right to left direction of
     the binary tree.
     """
     if not root:
@@ -183,5 +183,7 @@ def main():  # Main function for testing.
 
 
 if __name__ == "__main__":
+    # main()
     import doctest
+
     doctest.testmod()

From cf0f9e4568f103a7de3307b8df25d44e446871d8 Mon Sep 17 00:00:00 2001
From: Anshraj Shrivastava <42239140+rajansh87@users.noreply.github.com>
Date: Thu, 15 Oct 2020 12:58:05 +0530
Subject: [PATCH 14/31] Update binary_tree_traversals.py

---
 data_structures/binary_tree/binary_tree_traversals.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/data_structures/binary_tree/binary_tree_traversals.py b/data_structures/binary_tree/binary_tree_traversals.py
index b27aee724521..376834e4c325 100644
--- a/data_structures/binary_tree/binary_tree_traversals.py
+++ b/data_structures/binary_tree/binary_tree_traversals.py
@@ -185,5 +185,4 @@ def main():  # Main function for testing.
 if __name__ == "__main__":
     # main()
     import doctest
-
     doctest.testmod()

From 6c43555f0eee8ceb1671c7b4dd0af789a8e910ab Mon Sep 17 00:00:00 2001
From: Anshraj Shrivastava <42239140+rajansh87@users.noreply.github.com>
Date: Thu, 15 Oct 2020 13:02:13 +0530
Subject: [PATCH 15/31] Update binary_tree_traversals.py

---
 data_structures/binary_tree/binary_tree_traversals.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/data_structures/binary_tree/binary_tree_traversals.py b/data_structures/binary_tree/binary_tree_traversals.py
index 376834e4c325..2be52031d4b1 100644
--- a/data_structures/binary_tree/binary_tree_traversals.py
+++ b/data_structures/binary_tree/binary_tree_traversals.py
@@ -186,3 +186,4 @@ def main():  # Main function for testing.
     # main()
     import doctest
     doctest.testmod()
+    main()

From 449f686567512e48c088742fc34e744c42206f40 Mon Sep 17 00:00:00 2001
From: Anshraj Shrivastava <42239140+rajansh87@users.noreply.github.com>
Date: Thu, 15 Oct 2020 13:04:35 +0530
Subject: [PATCH 16/31] Update binary_tree_traversals.py

---
 data_structures/binary_tree/binary_tree_traversals.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/data_structures/binary_tree/binary_tree_traversals.py b/data_structures/binary_tree/binary_tree_traversals.py
index 2be52031d4b1..0381b4955adb 100644
--- a/data_structures/binary_tree/binary_tree_traversals.py
+++ b/data_structures/binary_tree/binary_tree_traversals.py
@@ -185,5 +185,6 @@ def main():  # Main function for testing.
 if __name__ == "__main__":
     # main()
     import doctest
+    
     doctest.testmod()
     main()

From 5dc55344e81cd99c15e5b3211695a1957b496642 Mon Sep 17 00:00:00 2001
From: Anshraj Shrivastava <42239140+rajansh87@users.noreply.github.com>
Date: Thu, 15 Oct 2020 13:06:38 +0530
Subject: [PATCH 17/31] Update binary_tree_traversals.py

---
 data_structures/binary_tree/binary_tree_traversals.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/data_structures/binary_tree/binary_tree_traversals.py b/data_structures/binary_tree/binary_tree_traversals.py
index 0381b4955adb..e397d0e4fcfc 100644
--- a/data_structures/binary_tree/binary_tree_traversals.py
+++ b/data_structures/binary_tree/binary_tree_traversals.py
@@ -187,4 +187,4 @@ def main():  # Main function for testing.
     import doctest
     
     doctest.testmod()
-    main()
+    

From 655657da31bcdb4973e8c4d46c2907b60522efef Mon Sep 17 00:00:00 2001
From: Anshraj Shrivastava <42239140+rajansh87@users.noreply.github.com>
Date: Thu, 15 Oct 2020 13:11:01 +0530
Subject: [PATCH 18/31] Update
 data_structures/binary_tree/binary_tree_traversals.py

Co-authored-by: Christian Clauss <cclauss@me.com>
---
 data_structures/binary_tree/binary_tree_traversals.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/data_structures/binary_tree/binary_tree_traversals.py b/data_structures/binary_tree/binary_tree_traversals.py
index e397d0e4fcfc..68d48365b461 100644
--- a/data_structures/binary_tree/binary_tree_traversals.py
+++ b/data_structures/binary_tree/binary_tree_traversals.py
@@ -24,6 +24,8 @@ def preorder(root):
     PreOrder traversal: visit root node
     then its left subtree followed
     by right subtree.
+    preorder(make_tree())
+    1 2 4 5 3
     """
     if root:
         print(root.data, end=" ")

From d5a0dba22e020dc55893ce049a03afe39f04c34a Mon Sep 17 00:00:00 2001
From: Anshraj Shrivastava <42239140+rajansh87@users.noreply.github.com>
Date: Thu, 15 Oct 2020 13:15:28 +0530
Subject: [PATCH 19/31] Update binary_tree_traversals.py

---
 data_structures/binary_tree/binary_tree_traversals.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/data_structures/binary_tree/binary_tree_traversals.py b/data_structures/binary_tree/binary_tree_traversals.py
index 68d48365b461..8bac5d81fef8 100644
--- a/data_structures/binary_tree/binary_tree_traversals.py
+++ b/data_structures/binary_tree/binary_tree_traversals.py
@@ -185,8 +185,8 @@ def main():  # Main function for testing.
 
 
 if __name__ == "__main__":
-    # main()
     import doctest
-    
+
     doctest.testmod()
+    # main()
     

From cd5c08cb25a013029d376d8558acf2d8c8ae8a76 Mon Sep 17 00:00:00 2001
From: Anshraj Shrivastava <42239140+rajansh87@users.noreply.github.com>
Date: Thu, 15 Oct 2020 13:17:21 +0530
Subject: [PATCH 20/31] Update binary_tree_traversals.py

---
 data_structures/binary_tree/binary_tree_traversals.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/data_structures/binary_tree/binary_tree_traversals.py b/data_structures/binary_tree/binary_tree_traversals.py
index 8bac5d81fef8..9e29770f2079 100644
--- a/data_structures/binary_tree/binary_tree_traversals.py
+++ b/data_structures/binary_tree/binary_tree_traversals.py
@@ -188,5 +188,5 @@ def main():  # Main function for testing.
     import doctest
 
     doctest.testmod()
-    # main()
+    
     

From b266c71e4286e1c93ddc033027783a65c036949a Mon Sep 17 00:00:00 2001
From: Anshraj Shrivastava <42239140+rajansh87@users.noreply.github.com>
Date: Thu, 15 Oct 2020 13:19:02 +0530
Subject: [PATCH 21/31] Update
 data_structures/binary_tree/binary_tree_traversals.py

Co-authored-by: Christian Clauss <cclauss@me.com>
---
 data_structures/binary_tree/binary_tree_traversals.py | 2 --
 1 file changed, 2 deletions(-)

diff --git a/data_structures/binary_tree/binary_tree_traversals.py b/data_structures/binary_tree/binary_tree_traversals.py
index 9e29770f2079..878405c9e149 100644
--- a/data_structures/binary_tree/binary_tree_traversals.py
+++ b/data_structures/binary_tree/binary_tree_traversals.py
@@ -188,5 +188,3 @@ def main():  # Main function for testing.
     import doctest
 
     doctest.testmod()
-    
-    

From fe91a5a258d0ac124b2de37284bd134fb600d7d7 Mon Sep 17 00:00:00 2001
From: Anshraj Shrivastava <42239140+rajansh87@users.noreply.github.com>
Date: Thu, 15 Oct 2020 13:46:20 +0530
Subject: [PATCH 22/31] Update
 data_structures/binary_tree/binary_tree_traversals.py

Co-authored-by: Christian Clauss <cclauss@me.com>
---
 data_structures/binary_tree/binary_tree_traversals.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/data_structures/binary_tree/binary_tree_traversals.py b/data_structures/binary_tree/binary_tree_traversals.py
index 878405c9e149..333c287ba288 100644
--- a/data_structures/binary_tree/binary_tree_traversals.py
+++ b/data_structures/binary_tree/binary_tree_traversals.py
@@ -24,7 +24,8 @@ def preorder(root):
     PreOrder traversal: visit root node
     then its left subtree followed
     by right subtree.
-    preorder(make_tree())
+
+    >>> preorder(make_tree())
     1 2 4 5 3
     """
     if root:

From ef6871eda7999707509cd88e443b3384aafb5071 Mon Sep 17 00:00:00 2001
From: Anshraj Shrivastava <42239140+rajansh87@users.noreply.github.com>
Date: Thu, 15 Oct 2020 14:16:12 +0530
Subject: [PATCH 23/31] Update binary_tree_traversals.py

---
 data_structures/binary_tree/binary_tree_traversals.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/data_structures/binary_tree/binary_tree_traversals.py b/data_structures/binary_tree/binary_tree_traversals.py
index 333c287ba288..878405c9e149 100644
--- a/data_structures/binary_tree/binary_tree_traversals.py
+++ b/data_structures/binary_tree/binary_tree_traversals.py
@@ -24,8 +24,7 @@ def preorder(root):
     PreOrder traversal: visit root node
     then its left subtree followed
     by right subtree.
-
-    >>> preorder(make_tree())
+    preorder(make_tree())
     1 2 4 5 3
     """
     if root:

From f1c3bfee31dcb33367559992fae055ed8821e311 Mon Sep 17 00:00:00 2001
From: Anshraj Shrivastava <42239140+rajansh87@users.noreply.github.com>
Date: Thu, 15 Oct 2020 14:17:35 +0530
Subject: [PATCH 24/31] Update
 data_structures/binary_tree/binary_tree_traversals.py

Co-authored-by: Christian Clauss <cclauss@me.com>
---
 data_structures/binary_tree/binary_tree_traversals.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/data_structures/binary_tree/binary_tree_traversals.py b/data_structures/binary_tree/binary_tree_traversals.py
index 878405c9e149..945ef1d9cc18 100644
--- a/data_structures/binary_tree/binary_tree_traversals.py
+++ b/data_structures/binary_tree/binary_tree_traversals.py
@@ -25,7 +25,7 @@ def preorder(root):
     then its left subtree followed
     by right subtree.
     preorder(make_tree())
-    1 2 4 5 3
+    1 2 4 5 3 
     """
     if root:
         print(root.data, end=" ")

From 6ae25e6d2c87ec782666f410921a7a5d2d45c09d Mon Sep 17 00:00:00 2001
From: Anshraj Shrivastava <42239140+rajansh87@users.noreply.github.com>
Date: Thu, 15 Oct 2020 14:19:40 +0530
Subject: [PATCH 25/31] Update binary_tree_traversals.py

---
 data_structures/binary_tree/binary_tree_traversals.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/data_structures/binary_tree/binary_tree_traversals.py b/data_structures/binary_tree/binary_tree_traversals.py
index 945ef1d9cc18..878405c9e149 100644
--- a/data_structures/binary_tree/binary_tree_traversals.py
+++ b/data_structures/binary_tree/binary_tree_traversals.py
@@ -25,7 +25,7 @@ def preorder(root):
     then its left subtree followed
     by right subtree.
     preorder(make_tree())
-    1 2 4 5 3 
+    1 2 4 5 3
     """
     if root:
         print(root.data, end=" ")

From 41a7dc1651b901ef74fbafe3e33e038136ff2a23 Mon Sep 17 00:00:00 2001
From: Christian Clauss <cclauss@me.com>
Date: Thu, 15 Oct 2020 11:47:39 +0200
Subject: [PATCH 26/31] Doctests and type hints

---
 .../binary_tree/binary_tree_traversals.py     | 111 ++++++++++--------
 1 file changed, 62 insertions(+), 49 deletions(-)

diff --git a/data_structures/binary_tree/binary_tree_traversals.py b/data_structures/binary_tree/binary_tree_traversals.py
index 878405c9e149..72d51e6ea078 100644
--- a/data_structures/binary_tree/binary_tree_traversals.py
+++ b/data_structures/binary_tree/binary_tree_traversals.py
@@ -19,12 +19,14 @@ def make_tree() -> Node:
     return root
 
 
-def preorder(root):
+def preorder(root: Node):
     """
-    PreOrder traversal: visit root node
-    then its left subtree followed
-    by right subtree.
-    preorder(make_tree())
+    PreOrder traversal visits
+    1. root node
+    2. left subtree
+    3. right subtree.
+
+    >>> preorder(make_tree())
     1 2 4 5 3
     """
     if root:
@@ -33,11 +35,15 @@ def preorder(root):
         preorder(root.right)
 
 
-def postorder(root):
+def postorder(root: Node):
     """
-    PostOrder traversal: visit left subtree
-    followed by right subtree
-    and then root node.
+    PostOrder traversal visits
+    1. left subtree
+    2. right subtree
+    3. root node
+
+    >>> postorder(make_tree())
+    4 5 2 3 1
     """
     if root:
         postorder(root.left)
@@ -45,11 +51,15 @@ def postorder(root):
         print(root.data, end=" ")
 
 
-def inorder(root):
+def inorder(root: Node):
     """
-    InOrder traversal: visit its leftsubtree
-    followed by root node and
-    then right subtree.
+    InOrder traversal visit
+    1. left subtree
+    2. root node
+    3. right subtree
+
+    >>> inorder(make_tree())
+    4 2 5 1 3
     """
     if root:
         inorder(root.left)
@@ -57,26 +67,27 @@ def inorder(root):
         inorder(root.right)
 
 
-def height(root):
+def height(root: Node):
     """
-    Recursive function for calculating
-    height of the binary tree.
+    Recursive function for calculating the height of the binary tree.
+
+    >>> height(make_tree())
+    3
     """
     if not root:
         return 0
     left_Height = height(root.left)
     right_Height = height(root.right)
-    if left_Height > right_Height:
-        return left_Height + 1
-    else:
-        return right_Height + 1
+    return max(left_Height, right_Height) + 1
 
 
-def levelorder1(root):
+def level_order_1(root: Node):
     """
     Print whole binary tree in Level Order Traverse.
-    Level Order traverse: Visit nodes
-    of the tree level-by-level.
+    Level Order traverse: Visit nodes of the tree level-by-level.
+
+    >>> level_order_1(make_tree())
+    1 2 3 4 5
     """
     if not root:
         return
@@ -91,26 +102,31 @@ def levelorder1(root):
             que.append(temp.right)
 
 
-def levelorder2(root, level):
+def level_order_2(root: Node, level: int):
     """
-    Level-wise traversal:
-    Print all nodes present at the
-    given level of the binary tree.
+    Level-wise traversal: Print all nodes present at the given level of the binary tree
+
+    >>> tree = make_tree()
+    >>> level_order_2(tree, 2)
+    2 3
+    >>> level_order_2(tree, 3)
+    4 5
     """
     if not root:
         return root
     if level == 1:
         print(root.data, end=" ")
     elif level > 1:
-        levelorder2(root.left, level - 1)
-        levelorder2(root.right, level - 1)
+        level_order_2(root.left, level - 1)
+        level_order_2(root.right, level - 1)
 
 
-def print_left_to_right(root, level):
+def print_left_to_right(root: Node, level: int):
     """
-    Print elements on particular level
-    from left to right direction of
-    the binary tree.
+    Print elements on particular level from left to right direction of the binary tree.
+
+    >>> print_left_to_right(make_tree(), 2)
+    2 3
     """
     if not root:
         return
@@ -121,11 +137,12 @@ def print_left_to_right(root, level):
         print_left_to_right(root.right, level - 1)
 
 
-def print_right_to_left(root, level):
+def print_right_to_left(root: Node, level: int):
     """
-    Print elements on particular level
-    from right to left direction of
-    the binary tree.
+    Print elements on particular level from right to left direction of the binary tree.
+
+    >>> print_right_to_left(make_tree(), 2)
+    3 2
     """
     if not root:
         return
@@ -136,11 +153,12 @@ def print_right_to_left(root, level):
         print_right_to_left(root.left, level - 1)
 
 
-def zigzag(root):
+def zigzag(root: Node):
     """
-    ZigZag traverse: Print node
-    left to right and
-    right to left, alternatively.
+    ZigZag traverse: Print node left to right and right to left, alternatively.
+
+    >>> zigzag(make_tree())
+    1 3 2 4 5
     """
     flag = 0
     height_tree = height(root)
@@ -157,12 +175,7 @@ def main():  # Main function for testing.
     """
     Create binary tree.
     """
-    root = Node(1)
-    root.left = Node(2)
-    root.right = Node(3)
-    root.left.left = Node(4)
-    root.left.right = Node(5)
-
+    root = make_tree()
     """
     All Traversals of the binary are as follows:
     """
@@ -176,10 +189,10 @@ def main():  # Main function for testing.
     height_tree = height(root)
     print(height_tree)
     print("\nComplete Level Order Traversal is : ")
-    levelorder1(root)
+    level_order_1(root)
     print("\nLevel-wise order Traversal is : ")
     for h in range(1, height_tree + 1):
-        levelorder2(root, h)
+        level_order_2(root, h)
     print("\nZigZag order Traversal is : ")
     zigzag(root)
 

From baa9eab60c9e99e40d718e24d35c3b30adb8a442 Mon Sep 17 00:00:00 2001
From: Christian Clauss <cclauss@me.com>
Date: Thu, 15 Oct 2020 11:59:52 +0200
Subject: [PATCH 27/31] Add spaces

---
 .../binary_tree/binary_tree_traversals.py      | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/data_structures/binary_tree/binary_tree_traversals.py b/data_structures/binary_tree/binary_tree_traversals.py
index 72d51e6ea078..077a3dc867a2 100644
--- a/data_structures/binary_tree/binary_tree_traversals.py
+++ b/data_structures/binary_tree/binary_tree_traversals.py
@@ -27,7 +27,7 @@ def preorder(root: Node):
     3. right subtree.
 
     >>> preorder(make_tree())
-    1 2 4 5 3
+    1 2 4 5 3 
     """
     if root:
         print(root.data, end=" ")
@@ -43,7 +43,7 @@ def postorder(root: Node):
     3. root node
 
     >>> postorder(make_tree())
-    4 5 2 3 1
+    4 5 2 3 1 
     """
     if root:
         postorder(root.left)
@@ -59,7 +59,7 @@ def inorder(root: Node):
     3. right subtree
 
     >>> inorder(make_tree())
-    4 2 5 1 3
+    4 2 5 1 3 
     """
     if root:
         inorder(root.left)
@@ -87,7 +87,7 @@ def level_order_1(root: Node):
     Level Order traverse: Visit nodes of the tree level-by-level.
 
     >>> level_order_1(make_tree())
-    1 2 3 4 5
+    1 2 3 4 5 
     """
     if not root:
         return
@@ -108,9 +108,9 @@ def level_order_2(root: Node, level: int):
 
     >>> tree = make_tree()
     >>> level_order_2(tree, 2)
-    2 3
+    2 3 
     >>> level_order_2(tree, 3)
-    4 5
+    4 5 
     """
     if not root:
         return root
@@ -126,7 +126,7 @@ def print_left_to_right(root: Node, level: int):
     Print elements on particular level from left to right direction of the binary tree.
 
     >>> print_left_to_right(make_tree(), 2)
-    2 3
+    2 3 
     """
     if not root:
         return
@@ -142,7 +142,7 @@ def print_right_to_left(root: Node, level: int):
     Print elements on particular level from right to left direction of the binary tree.
 
     >>> print_right_to_left(make_tree(), 2)
-    3 2
+    3 2 
     """
     if not root:
         return
@@ -158,7 +158,7 @@ def zigzag(root: Node):
     ZigZag traverse: Print node left to right and right to left, alternatively.
 
     >>> zigzag(make_tree())
-    1 3 2 4 5
+    1 3 2 4 5 
     """
     flag = 0
     height_tree = height(root)

From ce3546929c2811e7d15fccdb7912037a796794eb Mon Sep 17 00:00:00 2001
From: Anshraj Shrivastava <42239140+rajansh87@users.noreply.github.com>
Date: Thu, 15 Oct 2020 15:40:31 +0530
Subject: [PATCH 28/31] Update binary_tree_traversals.py

---
 .../binary_tree/binary_tree_traversals.py     | 27 +++++++------------
 1 file changed, 9 insertions(+), 18 deletions(-)

diff --git a/data_structures/binary_tree/binary_tree_traversals.py b/data_structures/binary_tree/binary_tree_traversals.py
index 077a3dc867a2..2b6bad301580 100644
--- a/data_structures/binary_tree/binary_tree_traversals.py
+++ b/data_structures/binary_tree/binary_tree_traversals.py
@@ -25,9 +25,8 @@ def preorder(root: Node):
     1. root node
     2. left subtree
     3. right subtree.
-
     >>> preorder(make_tree())
-    1 2 4 5 3 
+    1 2 4 5 3
     """
     if root:
         print(root.data, end=" ")
@@ -41,9 +40,8 @@ def postorder(root: Node):
     1. left subtree
     2. right subtree
     3. root node
-
     >>> postorder(make_tree())
-    4 5 2 3 1 
+    4 5 2 3 1
     """
     if root:
         postorder(root.left)
@@ -57,9 +55,8 @@ def inorder(root: Node):
     1. left subtree
     2. root node
     3. right subtree
-
     >>> inorder(make_tree())
-    4 2 5 1 3 
+    4 2 5 1 3
     """
     if root:
         inorder(root.left)
@@ -70,7 +67,6 @@ def inorder(root: Node):
 def height(root: Node):
     """
     Recursive function for calculating the height of the binary tree.
-
     >>> height(make_tree())
     3
     """
@@ -85,9 +81,8 @@ def level_order_1(root: Node):
     """
     Print whole binary tree in Level Order Traverse.
     Level Order traverse: Visit nodes of the tree level-by-level.
-
     >>> level_order_1(make_tree())
-    1 2 3 4 5 
+    1 2 3 4 5
     """
     if not root:
         return
@@ -105,12 +100,11 @@ def level_order_1(root: Node):
 def level_order_2(root: Node, level: int):
     """
     Level-wise traversal: Print all nodes present at the given level of the binary tree
-
     >>> tree = make_tree()
     >>> level_order_2(tree, 2)
-    2 3 
+    2 3
     >>> level_order_2(tree, 3)
-    4 5 
+    4 5
     """
     if not root:
         return root
@@ -124,9 +118,8 @@ def level_order_2(root: Node, level: int):
 def print_left_to_right(root: Node, level: int):
     """
     Print elements on particular level from left to right direction of the binary tree.
-
     >>> print_left_to_right(make_tree(), 2)
-    2 3 
+    2 3
     """
     if not root:
         return
@@ -140,9 +133,8 @@ def print_left_to_right(root: Node, level: int):
 def print_right_to_left(root: Node, level: int):
     """
     Print elements on particular level from right to left direction of the binary tree.
-
     >>> print_right_to_left(make_tree(), 2)
-    3 2 
+    3 2
     """
     if not root:
         return
@@ -156,9 +148,8 @@ def print_right_to_left(root: Node, level: int):
 def zigzag(root: Node):
     """
     ZigZag traverse: Print node left to right and right to left, alternatively.
-
     >>> zigzag(make_tree())
-    1 3 2 4 5 
+    1 3 2 4 5
     """
     flag = 0
     height_tree = height(root)

From 15c812d48b1665a2839c0502eb2b2d762cf78244 Mon Sep 17 00:00:00 2001
From: Christian Clauss <cclauss@me.com>
Date: Thu, 15 Oct 2020 12:11:22 +0200
Subject: [PATCH 29/31] black exclude
 data_structures/binary_tree/binary_tree_traversals.py

---
 .pre-commit-config.yaml | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 2fbb9cb9bdb2..e01fa983f310 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -16,6 +16,10 @@ repos:
     rev: stable
     hooks:
       - id: black
+    exclude: |
+      (?x)^(
+        data_structures/binary_tree/binary_tree_traversals.py
+      )$
   - repo: https://github.com/PyCQA/isort
     rev: 5.5.3
     hooks:

From 80409c5652659fbcc3317a431537ce20143c85a2 Mon Sep 17 00:00:00 2001
From: Christian Clauss <cclauss@me.com>
Date: Thu, 15 Oct 2020 12:21:04 +0200
Subject: [PATCH 30/31] Add spaces again

---
 .../binary_tree/binary_tree_traversals.py      | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/data_structures/binary_tree/binary_tree_traversals.py b/data_structures/binary_tree/binary_tree_traversals.py
index 2b6bad301580..a6abb6b4af03 100644
--- a/data_structures/binary_tree/binary_tree_traversals.py
+++ b/data_structures/binary_tree/binary_tree_traversals.py
@@ -26,7 +26,7 @@ def preorder(root: Node):
     2. left subtree
     3. right subtree.
     >>> preorder(make_tree())
-    1 2 4 5 3
+    1 2 4 5 3 
     """
     if root:
         print(root.data, end=" ")
@@ -41,7 +41,7 @@ def postorder(root: Node):
     2. right subtree
     3. root node
     >>> postorder(make_tree())
-    4 5 2 3 1
+    4 5 2 3 1 
     """
     if root:
         postorder(root.left)
@@ -56,7 +56,7 @@ def inorder(root: Node):
     2. root node
     3. right subtree
     >>> inorder(make_tree())
-    4 2 5 1 3
+    4 2 5 1 3 
     """
     if root:
         inorder(root.left)
@@ -82,7 +82,7 @@ def level_order_1(root: Node):
     Print whole binary tree in Level Order Traverse.
     Level Order traverse: Visit nodes of the tree level-by-level.
     >>> level_order_1(make_tree())
-    1 2 3 4 5
+    1 2 3 4 5 
     """
     if not root:
         return
@@ -102,9 +102,9 @@ def level_order_2(root: Node, level: int):
     Level-wise traversal: Print all nodes present at the given level of the binary tree
     >>> tree = make_tree()
     >>> level_order_2(tree, 2)
-    2 3
+    2 3 
     >>> level_order_2(tree, 3)
-    4 5
+    4 5 
     """
     if not root:
         return root
@@ -119,7 +119,7 @@ def print_left_to_right(root: Node, level: int):
     """
     Print elements on particular level from left to right direction of the binary tree.
     >>> print_left_to_right(make_tree(), 2)
-    2 3
+    2 3 
     """
     if not root:
         return
@@ -134,7 +134,7 @@ def print_right_to_left(root: Node, level: int):
     """
     Print elements on particular level from right to left direction of the binary tree.
     >>> print_right_to_left(make_tree(), 2)
-    3 2
+    3 2 
     """
     if not root:
         return
@@ -149,7 +149,7 @@ def zigzag(root: Node):
     """
     ZigZag traverse: Print node left to right and right to left, alternatively.
     >>> zigzag(make_tree())
-    1 3 2 4 5
+    1 3 2 4 5 
     """
     flag = 0
     height_tree = height(root)

From b7ea11640e727c5b2aafeba7ff95777218858dde Mon Sep 17 00:00:00 2001
From: Christian Clauss <cclauss@me.com>
Date: Thu, 15 Oct 2020 13:04:33 +0200
Subject: [PATCH 31/31] Update binary_tree_traversals.py

---
 .../binary_tree/binary_tree_traversals.py     | 83 ++++++-------------
 1 file changed, 25 insertions(+), 58 deletions(-)

diff --git a/data_structures/binary_tree/binary_tree_traversals.py b/data_structures/binary_tree/binary_tree_traversals.py
index a6abb6b4af03..7c0ee1dbbc2a 100644
--- a/data_structures/binary_tree/binary_tree_traversals.py
+++ b/data_structures/binary_tree/binary_tree_traversals.py
@@ -1,7 +1,9 @@
+# https://en.wikipedia.org/wiki/Tree_traversal
+
+
 class Node:
     """
-    A Node has data variable and pointers
-    to its left and right nodes.
+    A Node has data variable and pointers to its left and right nodes.
     """
 
     def __init__(self, data):
@@ -21,68 +23,46 @@ def make_tree() -> Node:
 
 def preorder(root: Node):
     """
-    PreOrder traversal visits
-    1. root node
-    2. left subtree
-    3. right subtree.
+    Pre-order traversal visits root node, left subtree, right subtree.
     >>> preorder(make_tree())
-    1 2 4 5 3 
+    [1, 2, 4, 5, 3]
     """
-    if root:
-        print(root.data, end=" ")
-        preorder(root.left)
-        preorder(root.right)
+    return [root.data] + preorder(root.left) + preorder(root.right) if root else []
 
 
 def postorder(root: Node):
     """
-    PostOrder traversal visits
-    1. left subtree
-    2. right subtree
-    3. root node
+    Post-order traversal visits left subtree, right subtree, root node.
     >>> postorder(make_tree())
-    4 5 2 3 1 
+    [4, 5, 2, 3, 1]
     """
-    if root:
-        postorder(root.left)
-        postorder(root.right)
-        print(root.data, end=" ")
+    return postorder(root.left) + postorder(root.right) + [root.data] if root else []
 
 
 def inorder(root: Node):
     """
-    InOrder traversal visit
-    1. left subtree
-    2. root node
-    3. right subtree
+    In-order traversal visits left subtree, root node, right subtree.
     >>> inorder(make_tree())
-    4 2 5 1 3 
+    [4, 2, 5, 1, 3]
     """
-    if root:
-        inorder(root.left)
-        print(root.data, end=" ")
-        inorder(root.right)
+    return inorder(root.left) + [root.data] + inorder(root.right) if root else []
 
 
 def height(root: Node):
     """
     Recursive function for calculating the height of the binary tree.
+    >>> height(None)
+    0
     >>> height(make_tree())
     3
     """
-    if not root:
-        return 0
-    left_Height = height(root.left)
-    right_Height = height(root.right)
-    return max(left_Height, right_Height) + 1
+    return (max(height(root.left), height(root.right)) + 1) if root else 0
 
 
 def level_order_1(root: Node):
     """
     Print whole binary tree in Level Order Traverse.
     Level Order traverse: Visit nodes of the tree level-by-level.
-    >>> level_order_1(make_tree())
-    1 2 3 4 5 
     """
     if not root:
         return
@@ -95,16 +75,12 @@ def level_order_1(root: Node):
             que.append(temp.left)
         if temp.right:
             que.append(temp.right)
+    return que
 
 
 def level_order_2(root: Node, level: int):
     """
     Level-wise traversal: Print all nodes present at the given level of the binary tree
-    >>> tree = make_tree()
-    >>> level_order_2(tree, 2)
-    2 3 
-    >>> level_order_2(tree, 3)
-    4 5 
     """
     if not root:
         return root
@@ -118,8 +94,6 @@ def level_order_2(root: Node, level: int):
 def print_left_to_right(root: Node, level: int):
     """
     Print elements on particular level from left to right direction of the binary tree.
-    >>> print_left_to_right(make_tree(), 2)
-    2 3 
     """
     if not root:
         return
@@ -133,8 +107,6 @@ def print_left_to_right(root: Node, level: int):
 def print_right_to_left(root: Node, level: int):
     """
     Print elements on particular level from right to left direction of the binary tree.
-    >>> print_right_to_left(make_tree(), 2)
-    3 2 
     """
     if not root:
         return
@@ -148,8 +120,6 @@ def print_right_to_left(root: Node, level: int):
 def zigzag(root: Node):
     """
     ZigZag traverse: Print node left to right and right to left, alternatively.
-    >>> zigzag(make_tree())
-    1 3 2 4 5 
     """
     flag = 0
     height_tree = height(root)
@@ -170,25 +140,22 @@ def main():  # Main function for testing.
     """
     All Traversals of the binary are as follows:
     """
-    print("In order Traversal is : ")
-    inorder(root)
-    print("\nPre order Traversal is : ")
-    preorder(root)
-    print("\nPost order Traversal is : ")
-    postorder(root)
-    print("\nHeight of Tree is : ")
-    height_tree = height(root)
-    print(height_tree)
-    print("\nComplete Level Order Traversal is : ")
+    print(f"  In-order Traversal is {inorder(root)}")
+    print(f" Pre-order Traversal is {preorder(root)}")
+    print(f"Post-order Traversal is {postorder(root)}")
+    print(f"Height of Tree is {height(root)}")
+    print("Complete Level Order Traversal is : ")
     level_order_1(root)
     print("\nLevel-wise order Traversal is : ")
-    for h in range(1, height_tree + 1):
+    for h in range(1, height(root) + 1):
         level_order_2(root, h)
     print("\nZigZag order Traversal is : ")
     zigzag(root)
+    print()
 
 
 if __name__ == "__main__":
     import doctest
 
     doctest.testmod()
+    main()