Deletion

README.md

@@ -0,0 +1,26 @@
+README
+
+A set of data structures that allow for the manipulation and implementation of Binary Search Trees.
+
+
+BST.py
+
+    BinarySearchTree is a class, that accepts a list or tuple of integers or floats on initiation and creates an instance of a Binary search tree.
+
+    *********
+    *Methods*
+    *********
+
+        *search- Accepts one parameter as integer or float. Will search instance of BST for value and return said Node if found. Returns None if not found. 
+
+        *insert- Accepts one parameter as integer or float. Will create a new Node with given value and insert into the BST properly.
+
+        *breadth_first- Returns a breadth first traversal generator of the current BST.
+
+        *Depth First Traversal*
+
+            *pre_order- Returns a depth first traversal, pre order, generator of the current BST.
+
+            *in_order- Returns a depth first traversal, in order, generator of the current BST.
+
+            *post_order- Returns a depth first traversal, post order, generator of the current BST.

setup.py

@@ -0,0 +1,22 @@
+from setuptools import setup
+
+extra_packages = {
+    'testing': ['ipython', 'pytest', 'pytest-cov', 'tox']
+}
+
+setup(
+    name='data-structures',
+    desctription='A variety of data structures built with Python.',
+    version='0.1',
+    author='James Salamonsen' 'Alex Short,
+    author_email='jamessalamonsen@gmail.com',
+    license='MIT',
+    py_modules=[],
+    package_dir={'': 'src'},
+    install_requires=[],
+    extras_require=extra_packages,
+    entry_points={
+        'console_scripts': [
+        ]
+    }
+)

src/BST.py

@@ -16,14 +16,14 @@ def __init__(self, iterable=None):
         # import pdb; pdb.set_trace()
         """This will sety what wwe will be iterating through."""
         self.visited = []
-        # self.list = []
+        self.list = []
         self.size = 0
         self.root = None
         self.iterable = iterable
         if iterable is not None:
             if type(iterable) in [list, tuple]:
                 for element in iterable:
-                    # self.list.append(element)
+                    self.list.append(element)
                     self.insert(element)
 
     def insert(self, entry):
@@ -43,15 +43,15 @@ def insert(self, entry):
                     else:
                         curr.right = Node(entry)
                         self.size += 1
-                        Node.parent = curr
+                        curr.right.parent = curr
                 elif entry < curr.val:
                     if curr.left:
                         curr = curr.left
                         continue
                     else:
                         curr.left = Node(entry)
                         self.size += 1
-                        Node.parent = curr
+                        curr.left.parent = curr
                 else:
                     return
 
@@ -61,7 +61,6 @@ def search(self, entry):
             raise TypeError("NUMBERS!!!!! numbers...")
         else:
             curr = self.root
-            # import pdb; pdb.set_trace()
             while curr:
                 if entry > curr.val:
                     if curr.right:
@@ -74,6 +73,15 @@ def search(self, entry):
                 else:
                     return curr
 
+    def depth_first(self, entry):
+        if entry is None:
+            return 0
+        left_depth = self.depth_first(entry.left)
+        right_depth = self.depth_first(entry.right)
+        if (left_depth > right_depth):
+            return left_depth + 1
+        return right_depth + 1
+
     def breadth_first(self):
         self.nodes_to_visit = []
         curr = self.root
@@ -137,13 +145,77 @@ def post_order(self):
         for node_data in self.post_order_trav():
             yield node_data
 
-    def deletion():
+    def check_that_balance(self, target=None):
+        """check the balance of your treeeee"""
+        if self.size == 0:
+            return 0
+        if not target:
+            target = self.root
+        else:
+            target = self.search(target)
+        return self.depth_first(target.right) - self.depth_first(target.left)
+
+    def find_min_depth(self, target):
+        curr = target
+        while curr.left is not None:
+            curr = curr.left
+        return curr
+
+    def find_max_depth(self, target):
+        curr = target
+        while curr.right is not None:
+            curr = curr.right
+        return curr
+
+    def deletion(self, target):
         """nope"""
-        pass
+        delete_node = self.search(target)
+        if delete_node is None:
+            return 'This is the end!'
+        else:
+            self.size -= 1
+            if delete_node.left is None and delete_node.right is None:
+                if delete_node.val > delete_node.parent.val:
+                    delete_node.parent.right = None
+                else:
+                    delete_node.parent.left = None
+            elif delete_node.left and not delete_node.right:
+                if delete_node.val > delete_node.parent.val:
+                    delete_node.parent.right = delete_node.left
+                    delete_node.left.parent = delete_node.parent
+                else:
+                    delete_node.parent.left = delete_node.left
+                    delete_node.left.parent = delete_node.parent
+            elif delete_node.right and not delete_node.left:
+                if delete_node.val > delete_node.parent.val:
+                    delete_node.parent.right = delete_node.right
+                    delete_node.right.parent = delete_node.parent
+                else:
+                    delete_node.parent.left = delete_node.right
+                    delete_node.left.parent = delete_node.parent
+            else:
+                if self.check_that_balance(target) > 0:
+                    min_val = self.find_min_depth(delete_node.right)
+                    delete_node.val = min_val.val
+                    if min_val.right is None:
+                        min_val.parent.left = None
+                        min_val.parent = None
+                    else:
+                        min_val.val = min_val.right.val
+                        min_val.right.parent = None
+                        min_val.right = None
+                else:
+                    max_val = self.find_max_depth(delete_node.left)
+                    delete_node.val = max_val.val
+                    if max_val.left is None:
+                        max_val.parent.right = None
+                        max_val.parent = None
+                    else:
+                        max_val.val = max_val.left.val
+                        max_val.left.parent = None
+                        max_val.left = None
 
-if __name__ == '__main__':
-    import sys
-    b = BinarySearchTree([5,3,7,2,8,4,9,1])
+if __name__ == '__main__':  # pragma: no cover
+    b = BinarySearchTree([5, 3, 7, 2, 8, 4, 9, 1])
     gen = b.in_order()
-    for i in range(5):
-        print(next(gen))
+    [i for i in gen]