BInary-Tree

Question 1

Traversal in Binary tree(Pre-order, Inorder, post-order traversal)

Traversal in Binary Tree

Answer 1

postorder DFS : left, right, root

Preorder traversal
(current-left-right)
Visits the node first, then left subtree, then right subtree

Inorder Traversal(left-current-right)

Visits left subtree- the Node - right subtree

Postorder Traversal(left-right-current)

Visits left subtree-right subtree- thenode

class Node:
def__init__(self, data):
self.data = data
self.left = None
self.right = None

		#inorder DFS:left, Root, Right
		def in_order_dfs(node):
		     if node is None:
		         return
  in_order_dfs(node.left)
  print(node.data, end=' ')
  in_order_dfs(node.right)

 #pre-order DFS: Root, left, Right
 def pre_order_dfs(node):
     if node is None:
		          return
  print(node.data, end = ' ')
    pre_order_dfs(node.left) pre_order_dfs(node.right)

def post_order_dfs(node):
if node is None:
return
post_order_dfs(node.left)
post_order_dfs(node.right)
print(node.data, end = ‘ ‘)

def bfs(root):
if root is None:
return
queue = [root]
while queue:
node = queue.pop(0)
print(node.data, end = ‘ ‘
if node.left:
queue.append(node.left)
if node.right:
queue.append(node.right)

if__name__ == “__main__”:
root = Node(2)
root.left = Node(3)
root.right = NOde(4)
root.left.left = Node(5)
print(“In-order DFS:”, end = ‘ ‘)
in_order_dfs(root)
print(“\n pre-order DFS:”, end = ‘ ‘)
pre_order_dfs(root)
print(“\n post order DFS:”, end = ‘ ‘)
post_order_dfs(root)
print(“\n level order :”, end = ‘ ‘)
bfs(root)

Question 2

Advantages of binary tree and disadvantages of binary tree

Answer 2

1)efficient search when compared to other data structures as linke dlist and arrays
2)Memory efficient binary trees are memory efficient compared other tree data strutures
3)Unbalanced tree where one subtree is singnificantly larger than the other can lead to inefficient search problems

Question 3

Basics of tree data structure