Binary Search Tree

Tree A tree is a nonlinear hierarchical data structure in which nodes are connected with each
others by edges
Binary Tree A binary tree is hierarchical data structure it has at most two nodes.
Full binary tree: A full binary tree is hierarchical data structure in which evry node consist either
0 child or two child.
complete binary tree: A complete binary tree is hierarchical data structure in which every level
must be fully filled except last level
Al most complete binary tree/ heap tree: Al most complete binary tree in which insertion takes
place level by level and from left to right order at each level and last level is not fully filled.
Binary Search Tree: Binary Search Tree is a hierarchical data strucure in which left child is less
than to its parent and right child is greater than to its parent
In [238… class Node:
def __init__(self,data):
self.data=data
self.left=None
self.right=None

class Binary_Search_Tree:
def __init__(self):
self.root=None

def insert_data (self,data):

New_node=Node(data)
if self.root==None:
self.root=New_node

current_node=self.root

while True:
if New_node.data==current_node.data:
return "Invalid Entry"

if New_node.data<current_node.data:
if current_node.left==None:
current_node.left=New_node
return True
current_node=current_node.left

else:
if current_node.right==None:
current_node.right=New_node
return True
 current_node=current_node.right

def search (self,data):

if self.root==None:
return "BST is empty"

current_node=self.root

while current_node!=None:

if data<current_node.data:
current_node=current_node.left

elif data>current_node.data:
current_node=current_node.right

else:
return "Element Found"

return "Not found"

def BFS_display(self): # Root,left_child, Rigt_child

current_node=self.root
Queue=[]
result=[]
Queue.append(current_node)

while len(Queue)>0 :
current_node=Queue.pop(0)
result.append(current_node.data)

if current_node.left!=None:
Queue.append(current_node.left)

if current_node.right!=None:
Queue.append(current_node.right)

return result

def DFS_inorder_display(self): # left, root, right

result=[]

def traverse (current_node):

if current_node.left!=None:
traverse(current_node.left)

result.append(current_node.data)

if current_node.right!=None:
traverse(current_node.right)

traverse(self.root)
 return result

def minimum_element (self):

current_node=self.root
while current_node.left!=None:
current_node=current_node.left

return current_node.data

In [239… BST=Binary_Search_Tree()

In [240… BST.insert_data(35)
BST.insert_data(3)
BST.insert_data(100)

Out[240]: True

In [241… BST.search(5)

Out[241]: 'Not found'

In [242… BST.search(3)

Out[242]: 'Element Found'

In [243… BST.BFS_display()

Out[243]: [35, 3, 100]

In [244… BST.DFS_inorder_display()

Out[244]: [3, 35, 100]

In [245… BST.minimum_element()

Out[245]: 3

recursive Binary Search Tree

In [246… class Node:
def __init__(self,data):
self.data=data
self.left=None
self.right=None

class Recursive_Binary_Search_Tree:
def __init__ (self):
 self.root=None

def __r_insert (self,current_node,data):

if current_node==None: #Base Case
current_node=Node(data)

if data< current_node.data:
current_node.left=self.__r_insert(current_node.left,data)

if data>current_node.data:
current_node.right=self.__r_insert(current_node.right,data)

return current_node

def r_insert(self,data):
if self.root==None:
self.root=Node(data)
else:
self.__r_insert(self.root,data)

def DFS_preorder_display (self):

result=[]
def traverse (current_node):
result.append(current_node.data)

if current_node.left!=None:
traverse(current_node.left)

if current_node.right!=None:
traverse(current_node.right)

traverse(self.root)
return result

def __r_search (self,current_node,data):

if current_node==None: #Base Case
return "Not Found"

if data==current_node.data:
return "Found"

if data<current_node.data:
return self.__r_search(current_node.left,data)

else:
return self.__r_search(current_node.right,data)

def r_search(self,data):
if self.root==None:
return "BST is empty"
else:
return self.__r_search(self.root,data)
 def minimum_element(self,current_node):
while current_node.left!=None:
current_node=current_node.left

return current_node.data

def __r_remove (self,current_node,data):

if current_node==None: # Base Case
return "Not found"

if data< current_node.data:
current_node.left=self.__r_remove(current_node.left,data)

elif data> current_node.data:

current_node.right=self.__r_remove(current_node.right,data)

else:
if current_node.left==None and current_node.right==None:
return None

if current_node.left==None:
current_node=current_node.right

elif current_node.right==None:
current_node=current_node.left

else:
right_sub_tree=self.minimum_element(current_node.right)
current_node.data=right_sub_tree
current_node.right=self.__r_remove(current_node.right,data)
return current_node

def r_remove(self,data):
if self.root==None:
return "BST is empty"

else:
self.__r_remove(self.root,data)

In [247… RBST=Recursive_Binary_Search_Tree()

In [248… RBST.r_insert(100)
RBST.r_insert(17)
RBST.r_insert(20)
RBST.r_insert(50)
RBST.r_insert(35)

In [249… RBST.DFS_preorder_display()

Out[249]: [100, 17, 20, 50, 35]

In [250… RBST.r_search(25)

Out[250]: 'Not Found'

In [251… RBST.r_search(50)

Out[251]: 'Found'

In [252… RBST.minimum_element(RBST.root)

Out[252]: 17

In [253… RBST.minimum_element(RBST.root.left)

Out[253]: 17

In [254… RBST.DFS_preorder_display()

Out[254]: [100, 17, 20, 50, 35]

In [255… RBST.r_remove(20)

In [256… RBST.DFS_preorder_display()

Out[256]: [100, 17, 50, 35]