sorting and binary tree delete

Author: Unknown

source/TreeMap.py

@@ -28,9 +28,9 @@ def height(self):
         downward path from this node to a descendant leaf node).
         Best case running time: O(1) if tree is empty
         Worst case running time: O(n) if the tree is on one long branch"""
-        right_height, left_height = 0
+        right_height, left_height = 0, 0
         # base case
-        if self.is_leaf:
+        if self.is_leaf():
             return 0
         if self.right:
             right_height = self.right.height() # use ternary
@@ -64,6 +64,9 @@ def height(self):
         # Check if root node has a value and if so calculate its height
         if self.root:
             return self.root.height()
+        else:
+            return 0
+
 
     def contains(self, item):
         """Return True if this binary search tree contains the given item.
@@ -113,11 +116,75 @@ def insert(self, item):
         # Increase the tree size
         self.size += 1
 
+    # swaps two nodes
+    def swap(self, a, b):
+        # swap data
+        a_data = a.data
+        b_data = b.data
+        a.data = b_data
+        b.data = a_data
+        # swap child pointers
+        a_left = a.left
+        a_right = a.right
+        a.left = b.left
+        a.right = b.right
+        b.left = a_left
+        b.right = a_right
+
+    def _find_successor(self, node):
+        # find the leftmost node in the right subtree
+        if node.right:
+            current = node.right
+            while current.left:
+                current = current.left
+            return current
+
+    def _find_predecessor(self, node):
+        if node.left:
+            current = node.left
+            while current.right:
+                current = current.right
+            return current.right
+
     def delete(self, item):
-        found = self.search(item)
-        if found:
+        found = self._find_node_recursive(item)
+        if found is not None:    # only attempt to delete if the element is present
             parent = self._find_parent_node(item)
 
+            # Case 1: node to be removed has no children
+            if not found.left and not found.right:
+                if self.root is found:
+                    self.root = None
+                else:
+                    if parent.right is found:
+                        parent.right = None
+                    elif parent.left is found:
+                        parent.left = None
+            # Case 2: node to be removed has one child
+            if found.right and not found.left:       # node to remove has only right child
+                if found is self.root:               # node to remove is root
+                    self.root = found.right
+                else:
+                    if parent.right is found:        # node to remove is right child
+                        parent.right = found.right
+                    if parent.left is found:         # node to remove is left child
+                        parent.left = found.right
+            if found.left and not found.right:       # node to remove has only left child
+                if found is self.root:               # node to remove is root
+                    self.root = found.left
+                else:
+                    if parent.right is found:        # node to remove is right child
+                        parent.right = found.left
+                    if parent.left is found:         # node to remove is left child
+                        parent.left = found.left
+
+            # Case 3: node to be removed has three children
+            # First find the successor (or predecessor) of the this node.
+            # Delete the successor (or predecessor) from the tree.
+            # Replace the node to be deleted with the successor (or predecessor)
+
+
+
     def _find_node_iterative(self, item):
         """Return the node containing the given item in this binary search tree,
         or None if the given item is not found.

source/binarytree.py

@@ -80,6 +80,12 @@ def test_init_with_list_of_tuples(self):
         assert tree.size == 3
         assert tree.is_empty() is False
 
+    def test_height(self):
+        tree = BinarySearchTree([2, 1, 3])
+        assert tree.height() == 1
+        tree.insert(4)
+        assert tree.height() == 2
+
     def test_size(self):
         tree = BinarySearchTree()
         assert tree.size == 0
@@ -90,6 +96,14 @@ def test_size(self):
         tree.insert('C')
         assert tree.size == 3
 
+    def test_delete(self):
+        tree = BinarySearchTree([2, 4])
+        assert tree.height() == 1
+        tree.delete(4)
+        assert tree.height() == 0
+        tree.delete(2)
+        assert tree.height() == 0
+
     def test_search_with_3_items(self):
         # Create a complete binary search tree of 3 items in level-order
         items = [2, 1, 3]

source/binarytree_test.py

@@ -0,0 +1,57 @@
+
+def selection_sort(to_sort):
+    min_index = 0
+    # go through each element in the list
+    for i in range(len(to_sort)):
+        # go through the part that hasn't been sorted yet
+        min_so_far = to_sort[i]
+        for j in range(i, len(to_sort)):
+            # find the min element in the unsorted part of the list
+            if list_to_sort[j] < min_so_far:
+                min_so_far = to_sort[j]
+                min_index = j
+        # swap the min element found and the current element of
+        # the unsorted list
+        temp = to_sort[i]
+        to_sort[i] = min_so_far
+        to_sort[min_index] = temp
+
+def bubble_sort(to_sort):
+    # we want to iterate until the list is sorted
+    # that is, until we iterate through and do not encounter
+    # a pair of elements that are out of order
+    not_sorted = True
+    while not_sorted:
+        not_sorted = False
+        # iterate through the unsorted part of the list
+        for i in range(len(to_sort) - 2):
+            # if we encounter two elements that are out of order
+            # that is, an element is smaller than the one that
+            # precedes it, then swap those elements and record that
+            # the list is not yet sorted, so that we iterate again
+            if to_sort[i + 1] < to_sort[i]:
+                to_sort[i + 1], to_sort[i] = to_sort[i], to_sort[i + 1]
+                not_sorted = True
+
+def insertion_sort(to_sort):
+    # iterate through each element
+    for i, item in enumerate(to_sort):
+        # store the current element
+        current_item = to_sort[i]
+        # find the index the current item belongs at by looping back through
+        for j in range(i, 0, -1):
+            # if the element to the left is greater than the current element,
+            # then swap the current element with that one (move it left)
+            if to_sort[j] > current_item:
+                temp = to_sort[j]
+                to_sort[j] = current_item
+                to_sort[j + 1] = temp
+
+
+if __name__ == '__main__':
+    numbers = [4, 8, 9, 10, -72, 21, 33, 99, 33]
+    insertion_sort(numbers)
+    print(numbers)
+    letters = ['a', 'p', 'z', 'c', 'g', 'j', 'j', 'e']
+    insertion_sort(letters)
+    print(letters)