Find maximum binary tree

data_structures_and_algorithms/challenges/find-maximum-binary-tree/bst.py

@@ -0,0 +1,104 @@
+class Node:
+    def __init__(self, val):
+        self.val = val
+        self.right = None
+        self.left = None
+
+    def __repr__(self):
+        return '<Node Val: {}>'.format(self.val)
+
+    def __str__(self):
+        return self.val
+
+
+class BST:
+    def __init__(self, iter=[]):
+        self.root = None
+        if not isinstance(iter, (str, tuple, list)):
+            raise TypeError('It\'s not an iterable type.')
+        for item in iter:
+            self.insert(item)
+
+    def __repr__(self):
+        return '<BST Root: {}>'.format(self.root.val)
+
+    def __str__(self):
+        val = self.root.val
+        return str(val)
+
+    def in_order(self, operation):
+        def _walk(node=None):
+            if node is None:
+                return
+
+            if node.left is not None:
+                _walk(node.left)
+
+            operation(node)
+
+            if node.right is not None:
+                _walk(node.right)
+
+        _walk(self.root)
+
+    def pre_order(self, operation):
+        def _walk(node=None):
+            if node is None:
+                return
+
+            operation(node)
+
+            if node.left is not None:
+                _walk(node.left)
+
+            if node.right is not None:
+                _walk(node.right)
+
+        _walk(self.root)
+
+    def post_order(self, operation):
+        def _walk(node=None):
+            if node is None:
+                return
+
+            if node.left is not None:
+                _walk(node.left)
+
+            if node.right is not None:
+                _walk(node.right)
+
+            operation(node)
+
+        _walk(self.root)
+
+    def insert(self, val):
+        if isinstance(val, Node):
+            node = val
+        else:
+            node = Node(val)
+
+        current = self.root
+
+        if self.root is None:
+            self.root = node
+            return node
+
+        while current:
+            try:
+                if val >= current.val:
+                    if current.right is not None:
+                        current = current.right
+                    else:
+                        current.right = node
+                        break
+
+                elif val < current.val:
+                    if current.left is not None:
+                        current = current.left
+                    else:
+                        current.left = node
+                        break
+            except TypeError:
+                raise TypeError('the value cannot be compared')
+
+        return node

data_structures_and_algorithms/challenges/find-maximum-binary-tree/find_maximum_binary_tree.py

@@ -0,0 +1,29 @@
+from .bst import BST
+
+
+def find_maximum_value(bst):
+    """ function finding max value from bst input \
+        it checks if input is of BST type \
+        and if root is empty
+    """
+    if not isinstance(bst, BST):
+        raise TypeError('It\'s not a BST type.')
+
+    if bst.root is None:
+        raise ValueError('BST is empty.')
+
+    max = 0
+    this_level = [bst.root]
+
+    while this_level:
+        next_level = list()
+        for n in this_level:
+            if n.val > max:
+                max = n.val
+            if n.left:
+                next_level.append(n.left)
+            if n.right:
+                next_level.append(n.right)
+        this_level = next_level
+
+    return max

data_structures_and_algorithms/challenges/find-maximum-binary-tree/read.md

@@ -0,0 +1,2 @@
+![image](https://github.com/MsDiala/data-structures-and-algorithms-python/blob/find-maximum-binary-tree/data_structures_and_algorithms/challenges/find-maximum-binary-tree/18_find_maximum_value.jpg)
+I got help from prev student in codefelowes 

data_structures_and_algorithms/data_structures/BinaryTree/maximum_binary_tree.py

@@ -0,0 +1,20 @@
+from  data_structures_and_algorithms.data_structures.tree.tree import Ktree
+
+def find_maximum_value(bst):
+    '''Find the maximum balue in a tree'''
+
+    if not isinstance(bst,Ktree):
+        raise TypeError('argument must be of type <BST')
+
+    if not bst.root:
+        return None
+
+    cur = bst.root.val
+
+    def update(node):
+        nonlocal cur
+        if node.val > cur:
+            cur = node.val
+
+    bst.pre_order(update)
+    return cur

data_structures_and_algorithms/data_structures/tree/tree.py

@@ -1,125 +1,105 @@
-class Node:
-    """Node class definition."""
 
-    def __init__(self, val=None):
-        """Create an instance of Node object."""
+class Node:
+    def __init__(self, val):
         self.val = val
-        self.children = []
-        self._next = next
+        self.right = None
+        self.left = None
 
     def __repr__(self):
-        """Node class representation."""
-        return '<Node Val: {}>'.format(self.val)
+        return self.val
 
     def __str__(self):
-        """Node class string printout."""
-        return 'Node Val: {}'.format(self.val)
+        return self.val
 
-class Queue:
-    def __init__(self, iter=[]):
-        self.front = None
-        self.back = None
-        self._length = 0
-
-        if not isinstance(iter, (list, dict, tuple)):
-            """ check for iterable """
-            raise TypeError('It is not iterable.')
-        for i in iter:
-            self.enqueue(i)
-
-    def enqueue(self, val):
-        """ add a value, increase size by 1"""
-        node = Node(val)
-        if self._length == 0:
-            self.front = self.back = node
-            self._length += 1
-            return node
-        self.back.next = node
-        self.back = node
-        self._length += 1
-        return node
-
-    def dequeue(self):
-        """ remove node from the front of queue """
-        if self._length == 0:
-            raise IndexError('You cannot dequeue() when front is empty')
-
-        temp = self.front
-        self.front = temp.next
-        self._length -= 1
-        return temp
-
-class KTree:
-    """Ktree class definition."""
 
-    def __init__(self):
-        """Create an instance of KTree object."""
+class Ktree:
+    def __init__(self, iter=[]):
         self.root = None
+
+        for item in iter:
+            self.insert(item)
 
     def __repr__(self):
-        """Ktree class representation."""
-        return '<KTree Root Val: {}>'.format(self.root.val)
+        return '<BST Root {}>'.format(self.root.val)
 
     def __str__(self):
-        """Ktree class string printout."""
-        return 'KTree Root Val: {}'.format(self.root.val)
+        return self.root.val
 
-    def pre_order(self, operation):
-        """Ktree pre_order traversal."""
+    def in_order(self, operation):
+        """in_order traversal"""
         def _walk(node=None):
             if node is None:
                 return
 
-            operation(node)
+            if node.left is not None:
+                _walk(node.left)
+            operation(node.val)
 
-            for child in node.children:
-                _walk(child)
+            if node.right is not None:
+                _walk(node.right)
 
-        _walk(self.root)
+        if self.root is None:
+            return False
+        else:
+            _walk(self.root)
+
+    def insert(self, val):
+        node = Node(val)
 
-    def post_order(self, operation):
-        """Ktree post_order traversal."""
+        def _insert(current, node):
+            """isert node in bst"""
+            if node.val >= current.val:
+                if current.right is None:
+                    current.right = node
+                else:
+                    current = current.right
+                    _insert(current, node)
+            if node.val < current.val:
+                if current.left is None:
+                    current.left = node
+                else:
+                    current = current.left
+                    _insert(current, node)
+
+        if self.root is None:
+            self.root = node
+            return node
+        else:
+            current = self.root
+            _insert(current, node)
+
+    def pre_order(self, operation):
+        """preorder traversal"""
         def _walk(node=None):
             if node is None:
                 return
+            operation(node.val)
+
+            if node.left is not None:
+                _walk(node.left)
+
+            if node.right is not None:
+                _walk(node.right)
+
+        if self.root is None:
+            return False
+        else:
+            _walk(self.root)
+
+    def post_order(self, operation):
+        """postorder traversal"""
+        def _walk(node=None):
+            if node.left is not None:
+                _walk(node.left)
 
-            for child in node.children:
-                _walk(child)
-
-            operation(node)
-
-        _walk(self.root)
-
-    def breadth_first_traversal(self, operation):
-        """Ktree breadth_first_traversal."""
-        queue = Queue()
-        queue.enqueue(self.root)
-        while queue._length > 0:
-            current = queue.dequeue()
-            operation(current)
-            for child in current.children:
-                queue.enqueue(child)
-
-    def insert(self, val, parent=None):
-        """Insert a value at first instance of given parent."""
-        if parent is None:
-            if self.root is None:
-                self.root = Node(val)
-                return self.root
-            raise ValueError('parent node is none.')
-
-        node = Node(val)
-
-        def _walk(curr=None):
-            if curr is None:
-                return
+            if node.right is not None:
+                _walk(node.right)
+            operation(node.val)
 
-            if curr.val == parent:
-                curr.children.append(node)
+            if node is None:
                 return
-
-            for child in curr.children:
-                _walk(child)
-                if node in child.children:
-                    return
-        _walk(self.root)
+
+        if self.root is None:
+            return False
+        else:
+            _walk(self.root)

test_find_maximum_binary_tree.py

@@ -0,0 +1,27 @@
+import pytest
+from .find_maximum_value_binary_tree import find_maximum_value
+from .bst import BST
+
+
+def test_typeerror_true():
+    """ test on input type """
+    with pytest.raises(TypeError):
+        find_maximum_value([1, 2, 3])
+
+
+def test_maximum_five(five_element_bst):
+    """ test for finding max from bst with five nodes. """
+    b = find_maximum_value(five_element_bst)
+    assert b == 9
+
+
+def test_maximum_seven(seven_element_bst):
+    """ test for finding max from bst with seven nodes. """
+    b = find_maximum_value(seven_element_bst)
+    assert b == 30
+
+
+def test_empty():
+    """ test for empty BST input """
+    with pytest.raises(ValueError):
+        find_maximum_value(BST())