12/1/22, 1:08 AM Implementing Tree and Linked List

In [1]: #first creating class called Node. For tree it has two component Root node node and tw

class Node(object):
def __init__(self,value):
self.value = value
self.left = None
self.right = None

class Binarytree(object):
def __init__(self,root):
self.root = Node(root)

root_node = Binarytree(1)
root_node.left = Binarytree(2)
root_node.right = Binarytree(2)

In [10]: #adding element to the tree

class Node:
def __init__(self,value):
self.value = value
self.left = None
self.right = None

def add_node(self, value):

if value == self.value:
return # node already exist

if value < self.value:

if self.left:
self.left.add_node(value)
else:
self.left = Node(value)
else:
if self.right:
self.right.add_node(value)
else:
self.right = Node(value)

def in_order_traversal(self):

elements = []

if self.left:
elements += self.left.in_order_traversal()

elements.append(self.value)

if self.right:
elements += self.right.in_order_traversal()
return elements

def pre_order_traversal(self):

elements = []

elements.append(self.value)
localhost:8888/nbconvert/html/Desktop/Implementing Tree and Linked List.ipynb?download=false 1/6
12/1/22, 1:08 AM Implementing Tree and Linked List

if self.left:
elements += self.left.pre_order_traversal()

if self.right:
elements += self.right.pre_order_traversal()

return elements

def post_order_traversal(self):

elements = []

if self.left:
elements += self.left.post_order_traversal()

if self.right:
elements += self.right.post_order_traversal()
elements.append(self.value)

return elements

def search(self,val):

if val == self.value:
return True
if val < self.value:

if val == self.left.search(val):
return True
else:
return False

if val > self.value:

if val == self.right.search(val):
return True
else:
return False

def find_min(self):
if self.left is None:
return self.value
return self.left.find_min()

def find_max(self):
if self.right is None:
return self.value
return self.right.find_max()

def delete(self,val):
if val < self.value:
if self.left:
self.left = self.left.delete(val)
elif val > self.value:
if self.right:
self.right = self.right.delete(val)
else:
if self.left is None and self.right is None:
localhost:8888/nbconvert/html/Desktop/Implementing Tree and Linked List.ipynb?download=false 2/6
12/1/22, 1:08 AM Implementing Tree and Linked List

return None

if self.left is None:
return self.right
if self.right is None:
return self.left

min_val = self.right.find_min()
self.value = min_val
self.right = self.right.delete(min_val)
return self

def build_tree(elements):
print("Building tree with these elements:",elements)
root = Node(elements[0])

for i in range(1,len(elements)):
root.add_node(elements[i])
return root

if __name__ == '__main__':

numbers_tree = build_tree([17, 4, 1, 20, 9, 23, 18, 34])

print("In order traversal gives this sorted list:",numbers_tree.in_order_traversal
print("Pre order traversal gives this sorted list:",numbers_tree.pre_order_travers
print("Post order traversal gives this sorted list:",numbers_tree.post_order_trave
print("Is a particular value in the tree? =",numbers_tree.search(1))
print("Fidng the min value in the tree? =",numbers_tree.find_min())
print("Fidng the max value in the tree? =",numbers_tree.find_max())
numbers_tree.delete(17)
print("After deleting 17 ",numbers_tree.in_order_traversal()) # this should print

Building tree with these elements: [17, 4, 1, 20, 9, 23, 18, 34]
In order traversal gives this sorted list: [1, 4, 9, 17, 18, 20, 23, 34]
Pre order traversal gives this sorted list: [17, 4, 1, 9, 20, 18, 23, 34]
Post order traversal gives this sorted list: [1, 9, 4, 18, 34, 23, 20, 17]
Is a particular value in the tree? = True
Fidng the min value in the tree? = 1
Fidng the max value in the tree? = 34
After deleting 17 [1, 4, 9, 18, 20, 23, 34]

In [29]: Node(2)
print(add_node)

<function add_node at 0x00000229B55705E0>

BFS
In [18]: import collections

graph = {
'5' : ['3','7'],
'3' : ['2', '4'],
'7' : ['8'],
'2' : [],
'4' : [],
'8' : []
}

localhost:8888/nbconvert/html/Desktop/Implementing Tree and Linked List.ipynb?download=false 3/6

12/1/22, 1:08 AM Implementing Tree and Linked List

def bfs(graph):
visited = []
queue = collections.deque('5')
while queue:
node = queue.popleft()
# print (node, end = " ")
visited.append(node)
for x in graph[node]:
queue.append(x)
return print(visited)

In [19]: bfs(graph)

['5', '3', '7', '2', '4', '8']

In [28]: graph = {
'5' : ['3','7'],
'3' : ['2', '4'],
'7' : ['8'],
'2' : [],
'4' : [],
'8' : []
}

visited = [] # List for visited nodes.

queue = [] #Initialize a queue

def bfs(visited, graph, node): #function for BFS

visited.append(node)
queue.append(node)

while queue: # Creating loop to visit each node

m = queue.pop(0)
print (m, end = " ")

for neighbour in graph[m]:

if neighbour not in visited:
visited.append(neighbour)
queue.append(neighbour)

# Driver Code
print("Following is the Breadth-First Search")
bfs(visited, graph, '5') # function calling

Following is the Breadth-First Search

5 3 7 2 4 8

DFS
In [20]: graph = {
'5' : ['3','7'],
'3' : ['2', '4'],
'7' : ['8'],
'2' : [],
'4' : [],

localhost:8888/nbconvert/html/Desktop/Implementing Tree and Linked List.ipynb?download=false 4/6

12/1/22, 1:08 AM Implementing Tree and Linked List
'8' : []
}

def dfs(graph):
visited = []
stack = ['5']
while stack:
node = stack.pop()
if node not in visited:
visited.append(node)
for x in graph[node]:
stack.append(x)
return print(visited)

In [21]: dfs(graph)

['5', '7', '8', '3', '4', '2']

In [24]: # Using a Python dictionary to act as an adjacency list

graph = {
'5' : ['3','7'],
'3' : ['2', '4'],
'7' : ['8'],
'2' : [],
'4' : [],
'8' : []
}

visited = set() # Set to keep track of visited nodes of graph.

def dfs(visited, graph, node): #function for dfs

if node not in visited:
print (node)
visited.add(node)
for neighbour in graph[node]:
dfs(visited, graph, neighbour)
# return print(visited)
# Driver Code
print("Following is the Depth-First Search")
dfs(visited, graph, '5')

Following is the Depth-First Search

5
3
2
4
7
8

Recursion
In [1]: def factorial(data):
if data == 1:
return data
else:
return data*factorial(data-1)

localhost:8888/nbconvert/html/Desktop/Implementing Tree and Linked List.ipynb?download=false 5/6

12/1/22, 1:08 AM Implementing Tree and Linked List

In [2]: factorial(5)

120
Out[2]:

In [ ]: class Node(odject):
def __init__ (self,val,left,right):
self.val = val
self.left = None
self.right = None
class BinaryTree(root):
self.root = Node(root)
self.left = left
self.right = right

root = BinaryTree(root)
root.left = left

localhost:8888/nbconvert/html/Desktop/Implementing Tree and Linked List.ipynb?download=false 6/6