Week:11

Write a Python program to perform the following:

a) Create a binary search tree.
b) Insert an element into a Binary search tree.

PROGRAM LOGIC:

1. The left sub tree of a node contains smaller nodes than a root node.
2. The right sub tree of a node contains greater nodes than a root node.
3. Both the left and right sub trees must also be binary search trees.
4. There are three types of tree traversals: Preorder, Postorder, and Inorder.

Pre-order traversal
Algorithm:
1. Visit the root (we will print it when we visit to show the order of visiting)
2. Traverse the left subtree in pre-order
3. Traverse the right subtree in pre-order

In-order traversal
Visit the root node in between the left and right node (in)
Algorithm:
1. Traverse the left subtree in in-order
2. Visit the root (we will print it when we visit to show the order of visiting)
3. Traverse the right subtree in in-order

Post-order traversal
Visit the root node after (post) visiting the left and right subtree.
Algorithm:
1. Traverse the left subtree in in-order
2. Traverse the right subtree in in-order
3. Visit the root (we will print it when we visit to show the order of visiting)

Maximum depth or Height of a tree

Algorithm:
maxDepth()
1. If tree is empty then return 0
2. Else
(a) Get the max depth of left subtree recursively i.e.,
call maxDepth( tree->left-subtree)
(a) Get the max depth of right subtree recursively i.e.,
call maxDepth( tree->right-subtree)
(c) Get the max of max depths of left and right

subtrees and add 1 to it for the current node.

max_depth = max(max dept of left subtree,
max depth of right subtree)
+1
(d) Return max_depth
Program:

class Node:

def __init__(self,info): #constructor of class

self.info = info #information for node

self.left = None #left leef

self.right = None #right leef

self.level = None #level none defined

def __str__(self):

return str(self.info) #return as string

class searchtree:

def __init__(self): #constructor of class

self.root = None

def create(self,val): #create binary search tree nodes

if self.root == None:

self.root = Node(val)

else:

current = self.root

while 1:

if val < current.info:

if current.left:

current = current.left

else:

current.left = Node(val)

break;

elif val > current.info:

if current.right:

current = current.right

else:

current.right = Node(val)
 break;

else:

break

def bft(self): #Breadth-First Traversal

self.root.level = 0

queue = [self.root]

out = []

current_level = self.root.level

while len(queue) > 0:

current_node = queue.pop(0)

if current_node.level > current_level:

current_level += 1

out.append("\n")

out.append(str(current_node.info) + " ")

if current_node.left:

current_node.left.level = current_level + 1

queue.append(current_node.left)

if current_node.right:

current_node.right.level = current_level + 1

queue.append(current_node.right)

result= "".join(out)

print (result)

def inorder(self,node):

if node is not None:

self.inorder(node.left)

print (node.info)

self.inorder(node.right)

def preorder(self,node):

if node is not None:

print (node.info)
 self.preorder(node.left)

self.preorder(node.right)

def postorder(self,node):

if node is not None:

self.postorder(node.left)

self.postorder(node.right)

print (node.info)

tree = searchtree()

arr = [8,3,1,6,4,7,10,14,13]

for i in arr:

tree.create(i)

print('Breadth-First Traversal')

tree.bft()

print ('Inorder Traversal')

tree.inorder(tree.root)

print ('Preorder Traversal')

tree.preorder(tree.root)

print ('Postorder Traversal')

tree.postorder(tree.root)

output:

Breadth-First Traversal

3 10

1 6 14

4 7 13

Inorder Traversal

6
7

10

13

14

Preorder Traversal

10

14

13

Postorder Traversal

13

14

10

Program: Count the number of nodes in the binary search tree.

class BinaryTree:

def __init__(self, data):

self.data = data
 self.left = None

self.right = None

def insert_left(self, new_data):

if self.left == None:

self.left = BinaryTree(new_data)

else:

t = BinaryTree(new_data)

t.left = self.left

self.left = t

def insert_right(self, new_data):

if self.right == None:

self.right = BinaryTree(new_data)

else:

t = BinaryTree(new_data)

t.right = self.right

self.right = t

def get_left(self):

return self.left

def get_right(self):

return self.right

def set_data(self, data):

self.data = data

def get_data(self):

return self.data

def size(my_tree):

if not my_tree:

return 0

return 1 + size(my_tree.get_left()) + size(my_tree.get_right())

a = BinaryTree(1)

a.insert_left(2)
a.insert_right(3)

print(size(a))

output: