From f17a5aa3b56be527217d5989b6acdd8beaf881d6 Mon Sep 17 00:00:00 2001
From: Matthew Lee <ml7@uw.edu>
Date: Mon, 9 Mar 2015 15:12:50 -0700
Subject: [PATCH 01/16] Readded parent information.

---
 bst.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/bst.py b/bst.py
index bb6d302..0a44007 100755
--- a/bst.py
+++ b/bst.py
@@ -52,6 +52,7 @@ def insert(self, value):
                 #actual insert
                 self.tree[value] = {'depth': depth}
                 self.tree[current][child] = value
+                self.tree[value]['parent'] = current
                 self._size += 1
                 if depth > self._depth:
                     self._depth = depth

From d46308cbfda4aa39620dbe4ddd9b81b020ecfeb2 Mon Sep 17 00:00:00 2001
From: Matthew Lee <ml7@uw.edu>
Date: Mon, 9 Mar 2015 15:13:56 -0700
Subject: [PATCH 02/16] Added helper function to get a parent for a given node.

---
 bst.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/bst.py b/bst.py
index 0a44007..19fd78c 100755
--- a/bst.py
+++ b/bst.py
@@ -21,10 +21,11 @@ def __init__(self, value=None):
     def left(self, current):
         return self.tree[current].get('left')
 
-
     def right(self, current):
         return self.tree[current].get('right')
 
+    def parent(self, current):
+        return self.tree[current].get('parent')
 
     def insert(self, value):
         """Insert a node with value in order.
@@ -49,7 +50,7 @@ def insert(self, value):
                 traverse = self.left(current)
                 child = 'left'
             if traverse is None:
-                #actual insert
+                # actual insert
                 self.tree[value] = {'depth': depth}
                 self.tree[current][child] = value
                 self.tree[value]['parent'] = current

From 28d888a69485837a901e5c3704dd8c2af0b92e38 Mon Sep 17 00:00:00 2001
From: Matthew Lee <ml7@uw.edu>
Date: Mon, 9 Mar 2015 15:22:40 -0700
Subject: [PATCH 03/16] Added first case for deletion function.

---
 bst.py | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/bst.py b/bst.py
index 19fd78c..a827cfb 100755
--- a/bst.py
+++ b/bst.py
@@ -60,6 +60,19 @@ def insert(self, value):
                 return
             current = traverse
 
+    def delete(self, val):
+        pass
+
+    def _delete(self, val, current):
+        left_of_parent = self.left(self.parent(current))
+        right_of_parent = self.right(self.parent(current))
+
+        if current == val:
+            if current == left_of_parent:
+                del self.tree[self.parent(current)]['left']
+            else:
+                del self.tree[self.parent(current)]['right']
+
     def balance(self):
         """Returns the balance of the tree:
 

From 88f48ed710d8b0adaa18230f37cc2606ade8800d Mon Sep 17 00:00:00 2001
From: Matthew Lee <ml7@uw.edu>
Date: Mon, 9 Mar 2015 15:31:33 -0700
Subject: [PATCH 04/16] Added simple case of deleting node with no children.

---
 bst.py      |  2 +-
 test_bst.py | 25 +++++++++++++++++++------
 2 files changed, 20 insertions(+), 7 deletions(-)

diff --git a/bst.py b/bst.py
index a827cfb..7b9582b 100755
--- a/bst.py
+++ b/bst.py
@@ -61,7 +61,7 @@ def insert(self, value):
             current = traverse
 
     def delete(self, val):
-        pass
+        self._delete(val, val)
 
     def _delete(self, val, current):
         left_of_parent = self.left(self.parent(current))
diff --git a/test_bst.py b/test_bst.py
index d1d546c..29473b3 100644
--- a/test_bst.py
+++ b/test_bst.py
@@ -18,23 +18,29 @@ def test_insert(empty_tree):
     tree.insert(30)
     expect = {20: {'depth': 1,
                    'right': 30},
-              30: {'depth': 2}}
+              30: {'depth': 2,
+                   'parent': 20}}
     assert tree.tree == expect
     tree.insert(40) 
     expect = {20: {'depth': 1,
                    'right': 30},
               30: {'depth': 2,
-                   'right': 40},
-              40: {'depth': 3}}
+                   'right': 40,
+                   'parent': 20},
+              40: {'depth': 3,
+                   'parent': 30}}
     assert tree.tree == expect
     tree.insert(10)
     expect = {20: {'depth': 1,
                    'left': 10,
                    'right': 30},
               30: {'depth': 2,
-                   'right': 40},
-              40: {'depth': 3},
-              10: {'depth': 2}}
+                   'right': 40,
+                   'parent': 20},
+              40: {'depth': 3,
+                   'parent': 30},
+              10: {'depth': 2,
+                   'parent': 20}}
     assert tree.tree == expect
 
 
@@ -119,6 +125,13 @@ def test_breadth_first_order(filled_tree):
         assert expected_order[place] == item
 
 
+def test_deletion_easy_case(filled_tree_2):
+    tree = filled_tree_2
+    assert tree.left(6) == 5
+    tree.delete(5)
+    assert tree.left(6) is None
+
+
 @pytest.fixture(scope='function')
 def filled_tree():
     """Upside down V Shaped Tree"""

From 4f1b3ee3e071a390364a6d79cbeae9e61cf119e7 Mon Sep 17 00:00:00 2001
From: Matthew Lee <ml7@uw.edu>
Date: Mon, 9 Mar 2015 15:38:25 -0700
Subject: [PATCH 05/16] Added tests for deleting nodes with one child, TODO:
 add assertions for depth.

---
 test_bst.py | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/test_bst.py b/test_bst.py
index 29473b3..5ac3487 100644
--- a/test_bst.py
+++ b/test_bst.py
@@ -132,6 +132,38 @@ def test_deletion_easy_case(filled_tree_2):
     assert tree.left(6) is None
 
 
+def test_deletion_one_left_child_lesser(filled_tree_2):
+    tree = filled_tree_2
+    assert tree.parent(6) == 4
+    assert tree.left(6) == 5
+    assert tree.right(6) is None
+    tree.delete(6)
+    assert tree.left(4) == 2
+    assert tree.right(4) == 5
+
+    assert tree.parent(5) == 4
+    assert tree.left(5) is None
+    assert tree.right(5) is None
+
+    assert tree.contains(6) is False
+
+
+def test_deletion_one_right_child_lesser(filled_tree_2):
+    tree = filled_tree_2
+    assert tree.parent(0) == 2
+    assert tree.left(0) is None
+    assert tree.right(0) == 1
+    tree.delete(0)
+    assert tree.left(2) == 1
+    assert tree.right(2) == 3
+
+    assert tree.parent(1) == 2
+    assert tree.left(1) is None
+    assert tree.right(1) is None
+
+    assert tree.contains(0) is False
+
+
 @pytest.fixture(scope='function')
 def filled_tree():
     """Upside down V Shaped Tree"""

From 09253c0142e3eddab30997cf0330019f0f2088f2 Mon Sep 17 00:00:00 2001
From: Henry Grantham <hgrantham@gmail.com>
Date: Tue, 10 Mar 2015 13:22:49 -0700
Subject: [PATCH 06/16] wrote node_depth funciton and removed node from
 dictionary. still now working

---
 bst.py | 22 +++++++++++++++-------
 1 file changed, 15 insertions(+), 7 deletions(-)

diff --git a/bst.py b/bst.py
index 232da93..a330e18 100755
--- a/bst.py
+++ b/bst.py
@@ -12,7 +12,7 @@ def __init__(self, value=None):
         self._depth = 0
 
         if value is not None:
-            self.tree[value] = {'depth': 1}
+            self.tree[value] = {}
             self.top = value
             self._size += 1
             self._depth += 1
@@ -31,7 +31,7 @@ def insert(self, value):
         In value is already present, it is ignored."""
         current = self.top
         if current is None:
-            self.tree[value] = {'depth': 1}
+            self.tree[value] = {}
             self.top = value
             self._size += 1
             self._depth += 1
@@ -49,7 +49,7 @@ def insert(self, value):
                 child = 'left'
             if traverse is None:
                 #actual insert
-                self.tree[value] = {'depth': depth}
+                self.tree[value] = {}
                 self.tree[current][child] = value
                 self._size += 1
                 if depth > self._depth:
@@ -69,11 +69,11 @@ def balance(self):
         right_deep = 0
         for node, v in self.tree.items():
             if self.top > node:
-                if left_deep < v['depth']:
-                    left_deep = v['depth']
+                if left_deep < self.node_depth(node):
+                    left_deep = self.node_depth(node)
             elif self.top < node:
-                if right_deep < v['depth']:
-                    right_deep = v['depth']
+                if right_deep < self.node_depth(node):
+                    right_deep = self.node_depth(node)
         return right_deep - left_deep
 
     def contains(self, value):
@@ -88,6 +88,14 @@ def depth(self):
         """Returns the depth of the tree."""
         return self._depth
 
+    def node_depth(self, current):
+        """Returns the depth of a node in the tree."""
+        depth = 0
+        while current:
+            current = current.parent(current)
+            depth +=1
+        return depth
+
     def get_dot(self):
         """return the tree with root 'self' as a dot graph for visualization"""
         return "digraph G{\n%s}" % ("" if not self.tree else (

From fb638b60728f4f39f8f441f2deeb49dfd08b03fc Mon Sep 17 00:00:00 2001
From: Henry Grantham <hgrantham@gmail.com>
Date: Tue, 10 Mar 2015 13:27:34 -0700
Subject: [PATCH 07/16] took out nodes from trees in test_bst.py

---
 test_bst.py | 27 +++++++++++----------------
 1 file changed, 11 insertions(+), 16 deletions(-)

diff --git a/test_bst.py b/test_bst.py
index 016501d..8546f0d 100644
--- a/test_bst.py
+++ b/test_bst.py
@@ -7,34 +7,29 @@ def test_Bst():
     tree = bst.Bst()
     assert tree.tree == {}
     tree = bst.Bst(5)
-    assert tree.tree == {5: {'depth': 1}}
+    assert tree.tree == {5: {}}
 
 
 def test_insert(empty_tree):
     """Test insert into a tree"""
     tree = empty_tree
     tree.insert(20)
-    assert tree.tree == {20: {'depth': 1}}
+    assert tree.tree == {20: {}}
     tree.insert(30)
-    expect = {20: {'depth': 1,
-                   'right': 30},
-              30: {'depth': 2}}
+    expect = {20: {'right': 30},
+              30: {}}
     assert tree.tree == expect
     tree.insert(40) 
-    expect = {20: {'depth': 1,
-                   'right': 30},
-              30: {'depth': 2,
-                   'right': 40},
-              40: {'depth': 3}}
+    expect = {20: {'right': 30},
+              30: {'right': 40},
+              40: {}}
     assert tree.tree == expect
     tree.insert(10)
-    expect = {20: {'depth': 1,
-                   'left': 10,
+    expect = {20: {'left': 10,
                    'right': 30},
-              30: {'depth': 2,
-                   'right': 40},
-              40: {'depth': 3},
-              10: {'depth': 2}}
+              30: {'right': 40},
+              40: {},
+              10: {}}
     assert tree.tree == expect
 
 

From 981ea381318a57462bd8aaa55ba654c678043b12 Mon Sep 17 00:00:00 2001
From: Henry Grantham <hgrantham@gmail.com>
Date: Tue, 10 Mar 2015 13:41:59 -0700
Subject: [PATCH 08/16] added test for node_depth

---
 test_bst.py | 47 ++++++++++++++++-------------------------------
 1 file changed, 16 insertions(+), 31 deletions(-)

diff --git a/test_bst.py b/test_bst.py
index b73a07c..0d0a758 100644
--- a/test_bst.py
+++ b/test_bst.py
@@ -16,46 +16,22 @@ def test_insert(empty_tree):
     tree.insert(20)
     assert tree.tree == {20: {}}
     tree.insert(30)
-<<<<<<< HEAD
     expect = {20: {'right': 30},
-              30: {}}
+              30: {'parent': 20}}
     assert tree.tree == expect
-    tree.insert(40) 
+    tree.insert(40)
     expect = {20: {'right': 30},
-              30: {'right': 40},
-              40: {}}
-=======
-    expect = {20: {'depth': 1,
-                   'right': 30},
-              30: {'depth': 2,
-                   'parent': 20}}
-    assert tree.tree == expect
-    tree.insert(40) 
-    expect = {20: {'depth': 1,
-                   'right': 30},
-              30: {'depth': 2,
-                   'right': 40,
+              30: {'right': 40,
                    'parent': 20},
-              40: {'depth': 3,
-                   'parent': 30}}
->>>>>>> 4f1b3ee3e071a390364a6d79cbeae9e61cf119e7
+              40: {'parent': 30}}
     assert tree.tree == expect
     tree.insert(10)
     expect = {20: {'left': 10,
                    'right': 30},
-<<<<<<< HEAD
-              30: {'right': 40},
-              40: {},
-              10: {}}
-=======
-              30: {'depth': 2,
-                   'right': 40,
+              30: {'right': 40,
                    'parent': 20},
-              40: {'depth': 3,
-                   'parent': 30},
-              10: {'depth': 2,
-                   'parent': 20}}
->>>>>>> 4f1b3ee3e071a390364a6d79cbeae9e61cf119e7
+              40: {'parent': 30},
+              10: {'parent': 20}}
     assert tree.tree == expect
 
 
@@ -179,6 +155,15 @@ def test_deletion_one_right_child_lesser(filled_tree_2):
     assert tree.contains(0) is False
 
 
+def test_node_depth(filled_tree_2):
+    assert filled_tree_2.node_depth(7) == 1
+    assert filled_tree_2.node_depth(4) == 2
+    assert filled_tree_2.node_depth(1) == 5
+    assert filled_tree_2.node_depth(13) == 4
+
+
+
+
 @pytest.fixture(scope='function')
 def filled_tree():
     """Upside down V Shaped Tree"""

From a416735f40a3ea21b7b77077991d338a393d2b6c Mon Sep 17 00:00:00 2001
From: Henry Grantham <hgrantham@gmail.com>
Date: Tue, 10 Mar 2015 13:42:36 -0700
Subject: [PATCH 09/16] fixed node_depth so it is correct when a node with
 value 0 exists

---
 bst.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/bst.py b/bst.py
index b8ae74a..02d73b8 100755
--- a/bst.py
+++ b/bst.py
@@ -108,8 +108,8 @@ def depth(self):
     def node_depth(self, current):
         """Returns the depth of a node in the tree."""
         depth = 0
-        while current:
-            current = current.parent(current)
+        while current is not None:
+            current = self.parent(current)
             depth +=1
         return depth
 

From 635fab23ecc51173ff80fc29ecc4afe479cd5f62 Mon Sep 17 00:00:00 2001
From: Henry Grantham <hgrantham@gmail.com>
Date: Tue, 10 Mar 2015 14:00:01 -0700
Subject: [PATCH 10/16] added _rightmost and tests for _rightmost

---
 bst.py      | 30 ++++++++++++++++++++++--------
 test_bst.py |  6 +++++-
 2 files changed, 27 insertions(+), 9 deletions(-)

diff --git a/bst.py b/bst.py
index 02d73b8..a8ce37d 100755
--- a/bst.py
+++ b/bst.py
@@ -62,17 +62,31 @@ def insert(self, value):
             current = traverse
 
     def delete(self, val):
-        self._delete(val, val)
+        if self.contains(val):
+            self._delete(val, val)
+
 
     def _delete(self, val, current):
-        left_of_parent = self.left(self.parent(current))
-        right_of_parent = self.right(self.parent(current))
+        pass
 
-        if current == val:
-            if current == left_of_parent:
-                del self.tree[self.parent(current)]['left']
-            else:
-                del self.tree[self.parent(current)]['right']
+
+    def _rightmost(self, start):
+        """Returns None if start is empty tree"""
+        while start is not None:
+            if self.right(start) is None:
+                return start
+            start = self.right(start)
+
+
+
+        # left_of_parent = self.left(self.parent(current))
+        # right_of_parent = self.right(self.parent(current))
+
+        # if current == val:
+        #     if current == left_of_parent:
+        #         del self.tree[self.parent(current)]['left']
+        #     else:
+        #         del self.tree[self.parent(current)]['right']
 
     def balance(self):
         """Returns the balance of the tree:
diff --git a/test_bst.py b/test_bst.py
index 0d0a758..8ce282b 100644
--- a/test_bst.py
+++ b/test_bst.py
@@ -161,7 +161,11 @@ def test_node_depth(filled_tree_2):
     assert filled_tree_2.node_depth(1) == 5
     assert filled_tree_2.node_depth(13) == 4
 
-
+def test_rightmost(filled_tree_2):
+    assert filled_tree_2._rightmost(0) == 1
+    assert filled_tree_2._rightmost(4) == 6
+    assert filled_tree_2._rightmost(7) == 13
+    assert filled_tree_2._rightmost(6) == 6
 
 
 @pytest.fixture(scope='function')

From 7f14b3cc36497b5965ed6f6f0174868e0803010c Mon Sep 17 00:00:00 2001
From: Matthew Lee <ml7@uw.edu>
Date: Tue, 10 Mar 2015 15:13:42 -0700
Subject: [PATCH 11/16] Added a internal method for swapping nodes.

---
 bst.py      | 42 ++++++++++++++++++++++++++++++++++++++++++
 test_bst.py | 14 ++++++++++++++
 2 files changed, 56 insertions(+)

diff --git a/bst.py b/bst.py
index a8ce37d..a1bb276 100755
--- a/bst.py
+++ b/bst.py
@@ -70,6 +70,47 @@ def _delete(self, val, current):
         pass
 
 
+    def _swap_nodes(self, current, target):
+        """
+        Swap two nodes.
+
+        Additionally, update all information on related nodes, as in, children
+        and parent nodes.
+        """
+        children = []
+
+        children.append(self.left(current))
+        children.append(self.right(current))
+        children.append(self.left(target))
+        children.append(self.right(target))
+
+        for child in children:
+            # If a node children, update it's childrens' information
+            # for 'swapping'
+            if child and self.parent(child) == current:
+                self.tree[child]['parent'] = target
+            elif child:
+                self.tree[child]['parent'] = current
+
+        # Swapping information in the parent nodes relative to the nodes being 'swapped'
+        if current != self.top:
+            if current == self.tree.get(self.parent(current)).get('left'):
+                self.tree[self.parent(current)]['left'] = target
+            else:
+                self.tree[self.parent(current)]['right'] = target
+
+        if target == self.tree.get(self.parent(target)).get('left'):
+            self.tree[self.parent(target)]['left'] = current
+        else:
+            self.tree[self.parent(target)]['right'] = current
+
+        # Swap current and target's left, right, and parent information
+        self.tree[current], self.tree[target] = self.tree[target], self.tree[current]
+
+        if current == self.top:
+            self.top = target
+
+
     def _rightmost(self, start):
         """Returns None if start is empty tree"""
         while start is not None:
@@ -215,6 +256,7 @@ def main():
     for i in inserts:
         tree.insert(i)
     print tree.tree
+    tree._swap_nodes(7, 5)
     # for num in enumerate(tree.pre_order()):
     #     print num
     dot_graph = tree.get_dot()
diff --git a/test_bst.py b/test_bst.py
index 8ce282b..a507a15 100644
--- a/test_bst.py
+++ b/test_bst.py
@@ -116,6 +116,20 @@ def test_breadth_first_order(filled_tree):
         assert expected_order[place] == item
 
 
+def test_swap(filled_tree_2):
+    tree = filled_tree_2
+    tree._swap_nodes(7, 5)
+    assert tree.top == 5
+
+    assert tree.parent(5) is None
+    assert tree.left(5) == 4
+    assert tree.right(5) == 11
+
+    assert tree.parent(7) == 6
+    assert tree.left(7) is None
+    assert tree.right(7) is None
+
+
 def test_deletion_easy_case(filled_tree_2):
     tree = filled_tree_2
     assert tree.left(6) == 5

From 23d8fa1dd9f40e767e08891adc0356a068317212 Mon Sep 17 00:00:00 2001
From: Henry Grantham <hgrantham@gmail.com>
Date: Tue, 10 Mar 2015 15:27:49 -0700
Subject: [PATCH 12/16] fixed swap sot that it stores parents in temp value

---
 bst.py | 18 +++++++++++-------
 1 file changed, 11 insertions(+), 7 deletions(-)

diff --git a/bst.py b/bst.py
index a1bb276..30db64f 100755
--- a/bst.py
+++ b/bst.py
@@ -77,6 +77,9 @@ def _swap_nodes(self, current, target):
         Additionally, update all information on related nodes, as in, children
         and parent nodes.
         """
+        cur_parent = self.parent(current)
+        targ_parent = self.parent(target)
+
         children = []
 
         children.append(self.left(current))
@@ -94,15 +97,15 @@ def _swap_nodes(self, current, target):
 
         # Swapping information in the parent nodes relative to the nodes being 'swapped'
         if current != self.top:
-            if current == self.tree.get(self.parent(current)).get('left'):
-                self.tree[self.parent(current)]['left'] = target
+            if current == self.tree.get(cur_parent).get('left'):
+                self.tree[cur_parent]['left'] = target
             else:
-                self.tree[self.parent(current)]['right'] = target
+                self.tree[cur_parent]['right'] = target
 
-        if target == self.tree.get(self.parent(target)).get('left'):
-            self.tree[self.parent(target)]['left'] = current
+        if target == self.tree.get(targ_parent).get('left'):
+            self.tree[targ_parent]['left'] = current
         else:
-            self.tree[self.parent(target)]['right'] = current
+            self.tree[targ_parent]['right'] = current
 
         # Swap current and target's left, right, and parent information
         self.tree[current], self.tree[target] = self.tree[target], self.tree[current]
@@ -255,8 +258,9 @@ def main():
     inserts = [7, 4, 11, 2, 9, 6, 12, 5, 13, 0, 10, 8, 3, 1]
     for i in inserts:
         tree.insert(i)
+
+    tree._swap_nodes(6, 4)
     print tree.tree
-    tree._swap_nodes(7, 5)
     # for num in enumerate(tree.pre_order()):
     #     print num
     dot_graph = tree.get_dot()

From f4c0bb931788c50214bbe1c04d23546bc826c1e9 Mon Sep 17 00:00:00 2001
From: Matthew Lee <ml7@uw.edu>
Date: Tue, 10 Mar 2015 15:29:40 -0700
Subject: [PATCH 13/16] Added tests for swapping parent/child nodes.

---
 test_bst.py | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/test_bst.py b/test_bst.py
index a507a15..7422be8 100644
--- a/test_bst.py
+++ b/test_bst.py
@@ -129,6 +129,18 @@ def test_swap(filled_tree_2):
     assert tree.left(7) is None
     assert tree.right(7) is None
 
+def test_swap_parentchild(filled_tree_2):
+    tree = filled_tree_2
+    tree._swap_nodes(7, 4)
+    assert tree.top == 4
+
+    assert tree.parent(4) is None
+    assert tree.left(4) == 7
+    assert tree.right(4) == 11
+
+    assert tree.parent(7) == 4
+    assert tree.left(7) is 2
+    assert tree.right(7) is 6
 
 def test_deletion_easy_case(filled_tree_2):
     tree = filled_tree_2

From 7cd9ed22f968a8c0fe93cc393445e1678f03820a Mon Sep 17 00:00:00 2001
From: Matthew Lee <ml7@uw.edu>
Date: Tue, 10 Mar 2015 15:34:22 -0700
Subject: [PATCH 14/16] Added parent references to dot graph for tree.

---
 bst.py | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/bst.py b/bst.py
index 30db64f..07a5eca 100755
--- a/bst.py
+++ b/bst.py
@@ -83,7 +83,7 @@ def _swap_nodes(self, current, target):
         children = []
 
         children.append(self.left(current))
-        children.append(self.right(current))
+        children.append(self.right(current))x`
         children.append(self.left(target))
         children.append(self.right(target))
 
@@ -185,6 +185,10 @@ def _get_dot(self, current):
         """recursively prepare a dot graph entry for this node."""
         left = self.tree[current].get('left')
         right = self.tree[current].get('right')
+        parent = self.tree[current].get('parent')
+        if parent is not None:
+            yield "\t%s -> %s;" % (current, parent)
+
         if left is not None:
             yield "\t%s -> %s;" % (current, left)
             for i in self._get_dot(left):
@@ -202,6 +206,7 @@ def _get_dot(self, current):
             yield "\tnull%s [shape=point];" % r
             yield "\t%s -> null%s;" % (current, r)
 
+
     def in_order(self, current='start'):
         """
         Generator that traverses the binary tree in order.

From 1d9f4604951e5f261e9d43b6d9f56a04c24cebd8 Mon Sep 17 00:00:00 2001
From: Matthew Lee <ml7@uw.edu>
Date: Tue, 10 Mar 2015 15:57:34 -0700
Subject: [PATCH 15/16] Added delete for simple case of no children, and
 recursive case for presence of a left child.

---
 bst.py      | 27 +++++++++++++++++++++------
 test_bst.py |  1 +
 2 files changed, 22 insertions(+), 6 deletions(-)

diff --git a/bst.py b/bst.py
index 07a5eca..963668f 100755
--- a/bst.py
+++ b/bst.py
@@ -63,11 +63,26 @@ def insert(self, value):
 
     def delete(self, val):
         if self.contains(val):
-            self._delete(val, val)
-
-
-    def _delete(self, val, current):
-        pass
+            left_child = self.left(val)
+            right_child = self.right(val)
+            parent = self.parent(val)
+            if left_child is None and right_child is None:
+                if parent:
+                    if self.left(parent) == val:
+                        del self.tree[parent]['left']
+                    else:
+                        del self.tree[parent]['right']
+                del self.tree[val]
+                print
+                print 'deletion'
+                print self.tree
+                print
+            elif left_child is not None:
+                biggest_child = self._rightmost(left_child)
+                self._swap_nodes(val, biggest_child)
+                print self.tree
+                print
+                self.delete(val)
 
 
     def _swap_nodes(self, current, target):
@@ -83,7 +98,7 @@ def _swap_nodes(self, current, target):
         children = []
 
         children.append(self.left(current))
-        children.append(self.right(current))x`
+        children.append(self.right(current))
         children.append(self.left(target))
         children.append(self.right(target))
 
diff --git a/test_bst.py b/test_bst.py
index 7422be8..e6ff7ea 100644
--- a/test_bst.py
+++ b/test_bst.py
@@ -147,6 +147,7 @@ def test_deletion_easy_case(filled_tree_2):
     assert tree.left(6) == 5
     tree.delete(5)
     assert tree.left(6) is None
+    assert tree.contains(5) is False
 
 
 def test_deletion_one_left_child_lesser(filled_tree_2):

From be37e9c50031435f7b86910862fac34052376d18 Mon Sep 17 00:00:00 2001
From: Matthew Lee <ml7@uw.edu>
Date: Tue, 10 Mar 2015 16:14:06 -0700
Subject: [PATCH 16/16] Fixed case of deleting a node that is on the left of
 it's parent, but only has a right child.

---
 bst.py      | 23 ++++++++++++++++-------
 test_bst.py |  1 +
 2 files changed, 17 insertions(+), 7 deletions(-)

diff --git a/bst.py b/bst.py
index 963668f..08b352b 100755
--- a/bst.py
+++ b/bst.py
@@ -67,22 +67,31 @@ def delete(self, val):
             right_child = self.right(val)
             parent = self.parent(val)
             if left_child is None and right_child is None:
-                if parent:
+            # Delete a node with not children
+                if parent is not None:
+                # For a node with a parent...
                     if self.left(parent) == val:
                         del self.tree[parent]['left']
                     else:
                         del self.tree[parent]['right']
+                else:
+                    # For deleting a node that is the root with no children
+                    self.top = None
                 del self.tree[val]
-                print
-                print 'deletion'
-                print self.tree
-                print
             elif left_child is not None:
                 biggest_child = self._rightmost(left_child)
                 self._swap_nodes(val, biggest_child)
-                print self.tree
-                print
                 self.delete(val)
+            else:
+                if parent is not None:
+                    if self.left(parent) == val:
+                        self.tree[parent]['left'] = right_child
+                    else:
+                        self.tree[parent]['right'] = right_child
+                    self.tree[right_child]['parent'] = parent
+                else:
+                    self.top = right_child
+                del self.tree[val]
 
 
     def _swap_nodes(self, current, target):
diff --git a/test_bst.py b/test_bst.py
index e6ff7ea..ee0ba17 100644
--- a/test_bst.py
+++ b/test_bst.py
@@ -172,6 +172,7 @@ def test_deletion_one_right_child_lesser(filled_tree_2):
     assert tree.left(0) is None
     assert tree.right(0) == 1
     tree.delete(0)
+
     assert tree.left(2) == 1
     assert tree.right(2) == 3