tree data structure

Author: raianmol172

Tree_data_structure/Binary_tree/find_min_max.py

@@ -0,0 +1,54 @@
+class Node:
+    def __init__(self, data):
+        self.data = data
+        self.left = None
+        self.right = None
+
+
+def findMaximum(root):
+
+    if root is None:
+        return 0
+
+    else:
+
+        maximum = root.data
+        if root.left:
+            left_max = findMaximum(root.left)
+            maximum = max(maximum, left_max)
+
+        if root.right:
+            right_max = findMaximum(root.right)
+            maximum = max(maximum, right_max)
+
+        return maximum
+
+
+def findMinimum(root):
+
+    if root is None:
+        return 0
+
+    else:
+
+        minimum = root.data
+
+        if root.left:
+            left_min = findMinimum(root.left)
+            minimum = min(minimum, left_min)
+
+        if root.right:
+            right_min = findMinimum(root.right)
+            minimum = min(minimum, right_min)
+
+        return minimum
+
+
+
+tree = Node(1)
+tree.left = Node(2)
+tree.right = Node(3)
+print('the maximum nodes value is: ')
+print(findMaximum(tree))
+print('the minimum nodes value is: ')
+print(findMinimum(tree))

Tree_data_structure/Binary_tree/height_tree.py

@@ -0,0 +1,24 @@
+class Node:
+    def __init__(self, data):
+        self.data = data
+        self.left = None
+        self.right = None
+
+
+def height(root):
+
+    if root is None:
+        return 0
+
+    else:
+
+        return 1 + max(height(root.left), height(root.right))
+
+
+tree = Node(1)
+tree.left = Node(2)
+tree.right = Node(3)
+tree.left.left = Node(4)
+print('the height of the tree: ')
+print(height(tree))
+

Tree_data_structure/Binary_tree/insertion_deletion.py

@@ -0,0 +1,97 @@
+class Node:
+    def __init__(self, data):
+        self.data = data
+        self.left = None
+        self.right = None
+
+
+def inorderTraversal(root):
+    if root is None:
+        return None
+    else:
+        inorderTraversal(root.left)
+        print(root.data, end=' ')
+        inorderTraversal(root.right)
+
+
+def insertion(root, key):
+    if not root:
+        return Node(key)
+    else:
+        q = [root]
+        while len(q):
+            temp = q.pop(0)
+            if temp.left is None:
+                temp.left = Node(key)
+                return
+            else:
+                q.append(temp.left)
+            if temp.right is None:
+                temp.right = Node(key)
+                return
+            else:
+                q.append(temp.right)
+
+
+def deletion(root, key):
+    if not root:
+        return None
+    if root.left is None and root.right is None:
+        if root.data == key:
+            return None
+        else:
+            return root
+    else:
+        key_node = None
+        q = [root]
+        while len(q):
+            temp = q.pop(0)
+            if temp.data == key:
+                key_node = temp
+            if temp.left:
+                q.append(temp.left)
+            if temp.right:
+                q.append(temp.right)
+        if key_node:
+            x = temp.data
+            deletionHelper(root, temp)
+            key_node.data = x
+            return root
+
+
+def deletionHelper(root, d_node):
+    q = [root]
+    while len(q):
+        temp = q.pop(0)
+        if temp.data is d_node:
+            temp.data = None
+            return
+        if temp.left is d_node:
+            temp.left = None
+            return
+        else:
+            q.append(temp.left)
+        if temp.right is d_node:
+            temp.right = None
+            return
+        else:
+            q.append(temp.right)
+
+
+tree = None
+tree = insertion(tree, 1)
+insertion(tree, 2)
+insertion(tree, 3)
+insertion(tree, 4)
+insertion(tree, 5)
+insertion(tree, 6)
+insertion(tree, 7)
+print('the inorder traversal of the tree: ')
+inorderTraversal(tree)
+print('\n After deletion: ')
+deletion(tree, 2)
+deletion(tree, 4)
+inorderTraversal(tree)
+
+
+

Tree_data_structure/Binary_tree/invert_tree.py

@@ -0,0 +1,39 @@
+class Node:
+    def __init__(self, data):
+        self.data = data
+        self.left = None
+        self.right = None
+
+
+def preorderTraversal(root):
+    if root is None:
+        return None
+    else:
+        print(root.data, end=' ')
+        preorderTraversal(root.left)
+        preorderTraversal(root.right)
+
+
+def invertTree(root):
+
+    if root is None:
+        return None
+
+    else:
+        root.left, root.right = root.right, root.left
+
+        root.left = invertTree(root.left)
+        root.right = invertTree(root.right)
+
+        return root
+
+
+tree = Node(1)
+tree.left = Node(2)
+tree.right = Node(3)
+print('before inverting/mirror_image the tree: ')
+preorderTraversal(tree)
+invertTree(tree)
+print('\n after inverting/mirror_image the tree: ')
+preorderTraversal(tree)
+

Tree_data_structure/Binary_tree/left_and_right_view.py

@@ -0,0 +1,55 @@
+class Node:
+    def __init__(self, data):
+        self.data = data
+        self.left = None
+        self.right = None
+
+
+def left_view(root):
+
+    if root is None:
+        return None
+
+    else:
+        q = [root]
+
+        while len(q):
+            for i in range(1, len(q) + 1):   # when the value of i==1 then print the popped node
+                temp = q.pop(0)
+                if i == 1:
+                    print(temp.data, end=' ')
+                if temp.left:
+                    q.append(temp.left)
+                if temp.right:
+                    q.append(temp.right)
+
+
+
+def right_view(root):
+
+    if root is None:
+        return None
+
+    else:
+        q = [root]
+
+        while len(q):
+            for i in range(1, len(q) + 1):   # when the value of i==1 then print the popped node
+                temp = q.pop(0)
+                if i == 1:
+                    print(temp.data, end=' ')
+                if temp.right:
+                    q.append(temp.right)
+                if temp.left:
+                    q.append(temp.left)
+
+
+tree = Node(1)
+tree.left = Node(2)
+tree.right = Node(3)
+tree.left.left = Node(4)
+tree.left.right = Node(5)
+print('left view of the tree: ')
+left_view(tree)
+print('\n right view of the tree: ')
+right_view(tree)

Tree_data_structure/Binary_tree/levelOrderTraversal.py

@@ -0,0 +1,34 @@
+class Node:
+    def __init__(self, data):
+        self.data = data
+        self.left = None
+        self.right = None
+
+
+def levelOrderTraversal(root):
+
+    if root is None:
+        return None
+
+    else:
+
+        q = [root]
+
+        while len(q):
+            temp = q.pop(0)
+            print(temp.data, end=' ')
+            if temp.left:
+                q.append(temp.left)
+            if temp.right:
+                q.append(temp.right)
+
+
+tree = Node(1)
+tree.left = Node(2)
+tree.right = Node(3)
+tree.left.left = Node(4)
+tree.left.right = Node(5)
+print('level order traversal: ')
+levelOrderTraversal(tree)
+
+

Tree_data_structure/Binary_tree/reverseLevelOrderTraversal.py

@@ -0,0 +1,34 @@
+class Node:
+    def __init__(self, data):
+        self.data = data
+        self.left = None
+        self.right = None
+
+
+def reverseLevelOrder(root):
+    if root is None:
+        return None
+    else:
+        q = [root]  # queue using array
+        s = []      # stack using array
+
+        while len(q):
+            temp = q.pop(0)
+            s.append(temp)
+            if temp.left:
+                q.append(temp.left)
+            if temp.right:
+                q.append(temp.right)
+
+        while len(s):
+            temp = s.pop()
+            print(temp.data, end=' ')
+
+
+tree = Node(1)
+tree.left = Node(2)
+tree.right = Node(3)
+tree.left.left = Node(4)
+tree.left.right = Node(5)
+print('reverse level order traversal:')
+reverseLevelOrder(tree)