add binary_tree_traversals.py to data_structures

.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:

data_structures/binary_tree/binary_tree_traversals.py

@@ -0,0 +1,161 @@
+# https://en.wikipedia.org/wiki/Tree_traversal
+
+
+class Node:
+ """
+ A Node has data variable and pointers to its left and right nodes.
+ """
+
+ def __init__(self, data):
+ self.left = None
+ self.right = None
+ 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: Node):
+ """
+ Pre-order traversal visits root node, left subtree, right subtree.
+ >>> preorder(make_tree())
+ [1, 2, 4, 5, 3]
+ """
+ return [root.data] + preorder(root.left) + preorder(root.right) if root else []
+
+
+def postorder(root: Node):
+ """
+ Post-order traversal visits left subtree, right subtree, root node.
+ >>> postorder(make_tree())
+ [4, 5, 2, 3, 1]
+ """
+ return postorder(root.left) + postorder(root.right) + [root.data] if root else []
+
+
+def inorder(root: Node):
+ """
+ In-order traversal visits left subtree, root node, right subtree.
+ >>> inorder(make_tree())
+ [4, 2, 5, 1, 3]
+ """
+ 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
+ """
+ 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.
+ """
+ if not root:
+ return
+ 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)
+ 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
+ """
+ if not root:
+ return root
+ if level == 1:
+ print(root.data, end=" ")
+ elif level > 1:
+ level_order_2(root.left, level - 1)
+ level_order_2(root.right, level - 1)
+
+
+def print_left_to_right(root: Node, level: int):
+ """
+ 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)
+
+
+def print_right_to_left(root: Node, level: int):
+ """
+ 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)
+
+
+def zigzag(root: Node):
+ """
+ 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
+ else:
+ print_right_to_left(root, h)
+ flag = 0
+
+
+def main(): # Main function for testing.
+ """
+ Create binary tree.
+ """
+ root = make_tree()
+ """
+ All Traversals of the binary are as follows:
+ """
+ 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(root) + 1):
+ level_order_2(root, h)
+ print("\nZigZag order Traversal is : ")
+ zigzag(root)
+ print()
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
+ main()