GitHub/interactive-coding-challenges
1
0
Fork 0
mirror of https://github.com/donnemartin/interactive-coding-challenges synced 2026-01-08 18:38:03 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #97 from donnemartin/develop

Browse Source 
Move tree challenges and solutions to classes
This commit is contained in:
Donne Martin
2016-08-14 08:31:06 -04:00
committed by GitHub
parent be5f29f98e 9176ffe214
commit 982580d051
20 changed files with 404 additions and 359 deletions
Download Patch File Download Diff File Expand all files Collapse all files

48
graphs_trees/bst/bst.py
View File

@@ -10,22 +10,34 @@ class Node(object):
return str(self.data) return str(self.data)
def insert(root, data): class Bst(object):
# Constraint: Assume we are working with valid ints
if root is None: def __init__(self, root=None):
root = Node(data) self.root = root
return root
if data <= root.data: def insert(self, data):
if root.left is None: if data is None:
root.left = insert(root.left, data) raise Exception('Data cannot be None')
root.left.parent = root if self.root is None:
return root.left self.root = Node(data)
return self.root
return self._insert(self.root, data)
def _insert(self, node, data):
# Constraint: Assume we are working with valid ints
if node is None:
return Node(data)
if data <= node.data:
if node.left is None:
node.left = self._insert(node.left, data)
node.left.parent = node
return node.left
else:
return self._insert(node.left, data)
else: else:
return insert(root.left, data) if node.right is None:
else: node.right = self._insert(node.right, data)
if root.right is None: node.right.parent = node
root.right = insert(root.right, data) return node.right
root.right.parent = root else:
return root.right return self._insert(node.right, data)
else:
return insert(root.right, data)

40
graphs_trees/bst/bst_challenge.ipynb
View File

@@ -98,9 +98,11 @@
" pass\n", " pass\n",
"\n", "\n",
"\n", "\n",
"def insert(root, data):\n", "class Bst(object):\n",
" # TODO: Implement me\n", "\n",
" pass" " def insert(self, data):\n",
" # TODO: Implement me\n",
" pass"
] ]
}, },
{ {
@@ -156,22 +158,25 @@
" def __init__(self):\n", " def __init__(self):\n",
" self.results = Results()\n", " self.results = Results()\n",
"\n", "\n",
" def test_tree(self):\n", " def test_tree_one(self):\n",
" node = Node(5)\n", " bst = Bst()\n",
" assert_equal(insert(node, 2).data, 2)\n", " bst.insert(5)\n",
" assert_equal(insert(node, 8).data, 8)\n", " bst.insert(2)\n",
" assert_equal(insert(node, 1).data, 1)\n", " bst.insert(8)\n",
" assert_equal(insert(node, 3).data, 3)\n", " bst.insert(1)\n",
" in_order_traversal(node, self.results.add_result)\n", " bst.insert(3)\n",
" in_order_traversal(bst.root, self.results.add_result)\n",
" assert_equal(str(self.results), '[1, 2, 3, 5, 8]')\n", " assert_equal(str(self.results), '[1, 2, 3, 5, 8]')\n",
" self.results.clear_results()\n", " self.results.clear_results()\n",
"\n", "\n",
" node = insert(None, 1)\n", " def test_tree_two(self):\n",
" assert_equal(insert(node, 2).data, 2)\n", " bst = Bst()\n",
" assert_equal(insert(node, 3).data, 3)\n", " bst.insert(1)\n",
" assert_equal(insert(node, 4).data, 4)\n", " bst.insert(2)\n",
" insert(node, 5)\n", " bst.insert(3)\n",
" in_order_traversal(node, self.results.add_result)\n", " bst.insert(4)\n",
" bst.insert(5)\n",
" in_order_traversal(bst.root, self.results.add_result)\n",
" assert_equal(str(self.results), '[1, 2, 3, 4, 5]')\n", " assert_equal(str(self.results), '[1, 2, 3, 4, 5]')\n",
"\n", "\n",
" print('Success: test_tree')\n", " print('Success: test_tree')\n",
@@ -179,7 +184,8 @@
"\n", "\n",
"def main():\n", "def main():\n",
" test = TestTree()\n", " test = TestTree()\n",
" test.test_tree()\n", " test.test_tree_one()\n",
" test.test_tree_two()\n",
"\n", "\n",
"\n", "\n",
"if __name__ == '__main__':\n", "if __name__ == '__main__':\n",

80
graphs_trees/bst/bst_solution.ipynb
View File

@@ -127,25 +127,37 @@
" return str(self.data)\n", " return str(self.data)\n",
"\n", "\n",
"\n", "\n",
"def insert(root, data):\n", "class Bst(object):\n",
" # Constraint: Assume we are working with valid ints\n", "\n",
" if root is None:\n", " def __init__(self, root=None):\n",
" root = Node(data)\n", " self.root = root\n",
" return root\n", "\n",
" if data <= root.data:\n", " def insert(self, data):\n",
" if root.left is None:\n", " if data is None:\n",
" root.left = insert(root.left, data)\n", " raise Exception('Data cannot be None')\n",
" root.left.parent = root\n", " if self.root is None:\n",
" return root.left\n", " self.root = Node(data)\n",
" return self.root\n",
" return self._insert(self.root, data)\n",
"\n",
" def _insert(self, node, data):\n",
" # Constraint: Assume we are working with valid ints\n",
" if node is None:\n",
" return Node(data)\n",
" if data <= node.data:\n",
" if node.left is None:\n",
" node.left = self._insert(node.left, data)\n",
" node.left.parent = node\n",
" return node.left\n",
" else:\n",
" return self._insert(node.left, data)\n",
" else:\n", " else:\n",
" return insert(root.left, data)\n", " if node.right is None:\n",
" else:\n", " node.right = self._insert(node.right, data)\n",
" if root.right is None:\n", " node.right.parent = node\n",
" root.right = insert(root.right, data)\n", " return node.right\n",
" root.right.parent = root\n", " else:\n",
" return root.right\n", " return self._insert(node.right, data)"
" else:\n",
" return insert(root.right, data)"
] ]
}, },
{ {
@@ -213,22 +225,25 @@
" def __init__(self):\n", " def __init__(self):\n",
" self.results = Results()\n", " self.results = Results()\n",
"\n", "\n",
" def test_tree(self):\n", " def test_tree_one(self):\n",
" node = Node(5)\n", " bst = Bst()\n",
" assert_equal(insert(node, 2).data, 2)\n", " bst.insert(5)\n",
" assert_equal(insert(node, 8).data, 8)\n", " bst.insert(2)\n",
" assert_equal(insert(node, 1).data, 1)\n", " bst.insert(8)\n",
" assert_equal(insert(node, 3).data, 3)\n", " bst.insert(1)\n",
" in_order_traversal(node, self.results.add_result)\n", " bst.insert(3)\n",
" in_order_traversal(bst.root, self.results.add_result)\n",
" assert_equal(str(self.results), '[1, 2, 3, 5, 8]')\n", " assert_equal(str(self.results), '[1, 2, 3, 5, 8]')\n",
" self.results.clear_results()\n", " self.results.clear_results()\n",
"\n", "\n",
" node = insert(None, 1)\n", " def test_tree_two(self):\n",
" assert_equal(insert(node, 2).data, 2)\n", " bst = Bst()\n",
" assert_equal(insert(node, 3).data, 3)\n", " bst.insert(1)\n",
" assert_equal(insert(node, 4).data, 4)\n", " bst.insert(2)\n",
" insert(node, 5)\n", " bst.insert(3)\n",
" in_order_traversal(node, self.results.add_result)\n", " bst.insert(4)\n",
" bst.insert(5)\n",
" in_order_traversal(bst.root, self.results.add_result)\n",
" assert_equal(str(self.results), '[1, 2, 3, 4, 5]')\n", " assert_equal(str(self.results), '[1, 2, 3, 4, 5]')\n",
"\n", "\n",
" print('Success: test_tree')\n", " print('Success: test_tree')\n",
@@ -236,7 +251,8 @@
"\n", "\n",
"def main():\n", "def main():\n",
" test = TestTree()\n", " test = TestTree()\n",
" test.test_tree()\n", " test.test_tree_one()\n",
" test.test_tree_two()\n",
"\n", "\n",
"\n", "\n",
"if __name__ == '__main__':\n", "if __name__ == '__main__':\n",

32
graphs_trees/bst/test_bst.py
View File

@@ -6,22 +6,25 @@ class TestTree(object):
def __init__(self): def __init__(self):
self.results = Results() self.results = Results()
def test_tree(self): def test_tree_one(self):
node = Node(5) bst = Bst()
assert_equal(insert(node, 2).data, 2) bst.insert(5)
assert_equal(insert(node, 8).data, 8) bst.insert(2)
assert_equal(insert(node, 1).data, 1) bst.insert(8)
assert_equal(insert(node, 3).data, 3) bst.insert(1)
in_order_traversal(node, self.results.add_result) bst.insert(3)
in_order_traversal(bst.root, self.results.add_result)
assert_equal(str(self.results), '[1, 2, 3, 5, 8]') assert_equal(str(self.results), '[1, 2, 3, 5, 8]')
self.results.clear_results() self.results.clear_results()
node = insert(None, 1) def test_tree_two(self):
assert_equal(insert(node, 2).data, 2) bst = Bst()
assert_equal(insert(node, 3).data, 3) bst.insert(1)
assert_equal(insert(node, 4).data, 4) bst.insert(2)
insert(node, 5) bst.insert(3)
in_order_traversal(node, self.results.add_result) bst.insert(4)
bst.insert(5)
in_order_traversal(bst.root, self.results.add_result)
assert_equal(str(self.results), '[1, 2, 3, 4, 5]') assert_equal(str(self.results), '[1, 2, 3, 4, 5]')
print('Success: test_tree') print('Success: test_tree')
@@ -29,7 +32,8 @@ class TestTree(object):
def main(): def main():
test = TestTree() test = TestTree()
test.test_tree() test.test_tree_one()
test.test_tree_two()
if __name__ == '__main__': if __name__ == '__main__':

35
graphs_trees/bst_min/bst_min_challenge.ipynb
View File

@@ -90,15 +90,10 @@
}, },
"outputs": [], "outputs": [],
"source": [ "source": [
"def create_min_bst(array):\n", "class MinBst(object):\n",
" # TODO: Implement me\n",
" # Calls _create_min_bst\n",
" pass \n",
"\n", "\n",
"\n", " def create_min_bst(self, array):\n",
"def _create_min_bst(array, start, end):\n", " # TODO: Implement me"
" # TODO: Implement me\n",
" pass"
] ]
}, },
{ {
@@ -115,17 +110,6 @@
"**The following unit test is expected to fail until you solve the challenge.**" "**The following unit test is expected to fail until you solve the challenge.**"
] ]
}, },
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"%run ../tree_height/height.py"
]
},
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": null, "execution_count": null,
@@ -138,15 +122,24 @@
"from nose.tools import assert_equal\n", "from nose.tools import assert_equal\n",
"\n", "\n",
"\n", "\n",
"def height(node):\n",
" if node is None:\n",
" return 0\n",
" return 1 + max(height(node.left),\n",
" height(node.right))\n",
"\n",
"\n",
"class TestBstMin(object):\n", "class TestBstMin(object):\n",
"\n", "\n",
" def test_bst_min(self):\n", " def test_bst_min(self):\n",
" min_bst = MinBst()\n",
" array = [0, 1, 2, 3, 4, 5, 6]\n", " array = [0, 1, 2, 3, 4, 5, 6]\n",
" root = create_min_bst(array)\n", " root = min_bst.create_min_bst(array)\n",
" assert_equal(height(root), 3)\n", " assert_equal(height(root), 3)\n",
"\n", "\n",
" min_bst = MinBst()\n",
" array = [0, 1, 2, 3, 4, 5, 6, 7]\n", " array = [0, 1, 2, 3, 4, 5, 6, 7]\n",
" root = create_min_bst(array)\n", " root = min_bst.create_min_bst(array)\n",
" assert_equal(height(root), 4)\n", " assert_equal(height(root), 4)\n",
"\n", "\n",
" print('Success: test_bst_min')\n", " print('Success: test_bst_min')\n",

51
graphs_trees/bst_min/bst_min_solution.ipynb
View File

@@ -102,20 +102,21 @@
"from __future__ import division\n", "from __future__ import division\n",
"\n", "\n",
"\n", "\n",
"def create_min_bst(array):\n", "class MinBst(object):\n",
" if array is None:\n",
" return\n",
" return _create_min_bst(array, 0, len(array)-1)\n",
"\n", "\n",
" def create_min_bst(self, array):\n",
" if array is None:\n",
" return\n",
" return self._create_min_bst(array, 0, len(array)-1)\n",
"\n", "\n",
"def _create_min_bst(array, start, end):\n", " def _create_min_bst(self, array, start, end):\n",
" if end < start:\n", " if end < start:\n",
" return None\n", " return None\n",
" mid = (start + end) // 2\n", " mid = (start + end) // 2\n",
" node = Node(array[mid])\n", " node = Node(array[mid])\n",
" node.left = _create_min_bst(array, start, mid-1)\n", " node.left = self._create_min_bst(array, start, mid-1)\n",
" node.right = _create_min_bst(array, mid+1, end)\n", " node.right = self._create_min_bst(array, mid+1, end)\n",
" return node" " return node"
] ]
}, },
{ {
@@ -128,17 +129,6 @@
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 3, "execution_count": 3,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"%run ../tree_height/height.py"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": { "metadata": {
"collapsed": false "collapsed": false
}, },
@@ -156,15 +146,24 @@
"from nose.tools import assert_equal\n", "from nose.tools import assert_equal\n",
"\n", "\n",
"\n", "\n",
"def height(node):\n",
" if node is None:\n",
" return 0\n",
" return 1 + max(height(node.left),\n",
" height(node.right))\n",
"\n",
"\n",
"class TestBstMin(object):\n", "class TestBstMin(object):\n",
"\n", "\n",
" def test_bst_min(self):\n", " def test_bst_min(self):\n",
" min_bst = MinBst()\n",
" array = [0, 1, 2, 3, 4, 5, 6]\n", " array = [0, 1, 2, 3, 4, 5, 6]\n",
" root = create_min_bst(array)\n", " root = min_bst.create_min_bst(array)\n",
" assert_equal(height(root), 3)\n", " assert_equal(height(root), 3)\n",
"\n", "\n",
" min_bst = MinBst()\n",
" array = [0, 1, 2, 3, 4, 5, 6, 7]\n", " array = [0, 1, 2, 3, 4, 5, 6, 7]\n",
" root = create_min_bst(array)\n", " root = min_bst.create_min_bst(array)\n",
" assert_equal(height(root), 4)\n", " assert_equal(height(root), 4)\n",
"\n", "\n",
" print('Success: test_bst_min')\n", " print('Success: test_bst_min')\n",
@@ -181,7 +180,7 @@
}, },
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 5, "execution_count": 4,
"metadata": { "metadata": {
"collapsed": false "collapsed": false
}, },

13
graphs_trees/bst_min/test_bst_min.py
View File

@@ -1,15 +1,24 @@
from nose.tools import assert_equal from nose.tools import assert_equal
def height(node):
if node is None:
return 0
return 1 + max(height(node.left),
height(node.right))
class TestBstMin(object): class TestBstMin(object):
def test_bst_min(self): def test_bst_min(self):
min_bst = MinBst()
array = [0, 1, 2, 3, 4, 5, 6] array = [0, 1, 2, 3, 4, 5, 6]
root = create_min_bst(array) root = min_bst.create_min_bst(array)
assert_equal(height(root), 3) assert_equal(height(root), 3)
min_bst = MinBst()
array = [0, 1, 2, 3, 4, 5, 6, 7] array = [0, 1, 2, 3, 4, 5, 6, 7]
root = create_min_bst(array) root = min_bst.create_min_bst(array)
assert_equal(height(root), 4) assert_equal(height(root), 4)
print('Success: test_bst_min') print('Success: test_bst_min')

43
graphs_trees/bst_successor/bst_successor_challenge.ipynb
View File

@@ -105,9 +105,11 @@
}, },
"outputs": [], "outputs": [],
"source": [ "source": [
"def bst_successor(node):\n", "class BstSuccessor(object):\n",
" # TODO: Implement me\n", "\n",
" pass" " def get_next(self, node):\n",
" # TODO: Implement me\n",
" pass"
] ]
}, },
{ {
@@ -141,28 +143,31 @@
"\n", "\n",
" @raises(Exception)\n", " @raises(Exception)\n",
" def test_bst_successor_empty(self):\n", " def test_bst_successor_empty(self):\n",
" bst_successor(None)\n", " bst_successor = BstSuccessor()\n",
" bst_successor.get_next(None)\n",
"\n", "\n",
" def test_bst_successor(self):\n", " def test_bst_successor(self):\n",
" nodes = {}\n", " nodes = {}\n",
" node = Node(5)\n", " node = Node(5)\n",
" nodes[5] = node\n", " nodes[5] = node\n",
" nodes[3] = insert(node, 3)\n", " bst = Bst(nodes[5])\n",
" nodes[8] = insert(node, 8)\n", " nodes[3] = bst.insert(3)\n",
" nodes[2] = insert(node, 2)\n", " nodes[8] = bst.insert(8)\n",
" nodes[4] = insert(node, 4)\n", " nodes[2] = bst.insert(2)\n",
" nodes[6] = insert(node, 6)\n", " nodes[4] = bst.insert(4)\n",
" nodes[12] = insert(node, 12)\n", " nodes[6] = bst.insert(6)\n",
" nodes[1] = insert(node, 1)\n", " nodes[12] = bst.insert(12)\n",
" nodes[7] = insert(node, 7)\n", " nodes[1] = bst.insert(1)\n",
" nodes[10] = insert(node, 10)\n", " nodes[7] = bst.insert(7)\n",
" nodes[15] = insert(node, 15)\n", " nodes[10] = bst.insert(10)\n",
" nodes[9] = insert(node, 9)\n", " nodes[15] = bst.insert(15)\n",
" nodes[9] = bst.insert(9)\n",
"\n", "\n",
" assert_equal(bst_successor(nodes[4]), 5)\n", " bst_successor = BstSuccessor()\n",
" assert_equal(bst_successor(nodes[5]), 6)\n", " assert_equal(bst_successor.get_next(nodes[4]), 5)\n",
" assert_equal(bst_successor(nodes[8]), 9)\n", " assert_equal(bst_successor.get_next(nodes[5]), 6)\n",
" assert_equal(bst_successor(nodes[15]), None)\n", " assert_equal(bst_successor.get_next(nodes[8]), 9)\n",
" assert_equal(bst_successor.get_next(nodes[15]), None)\n",
"\n", "\n",
" print('Success: test_bst_successor')\n", " print('Success: test_bst_successor')\n",
"\n", "\n",

76
graphs_trees/bst_successor/bst_successor_solution.ipynb
View File

@@ -111,29 +111,28 @@
}, },
"outputs": [], "outputs": [],
"source": [ "source": [
"def left_most_node(node):\n", "class BstSuccessor(object):\n",
" if node is None:\n", "\n",
" return None\n", " def get_next(self, node):\n",
" if node.left is None:\n", " if node is None:\n",
" raise Exception('Invalid input node')\n",
" if node.right is not None:\n",
" return self._left_most(node.right)\n",
" return self._next_ancestor(node)\n",
"\n",
" def _left_most(self, node):\n",
" if node.left is not None:\n",
" return self._left_most(node.left)\n",
" return node.data\n", " return node.data\n",
" return left_most_node(node.left)\n",
"\n", "\n",
"\n", " def _next_ancestor(self, node):\n",
"def bst_successor(node):\n", " if node.parent is not None:\n",
" if node is None:\n", " if node.parent.data > node.data:\n",
" raise Exception('Invalid input node')\n", " return node.parent.data\n",
" if node.right is not None:\n", " return self._next_ancestor(node.parent)\n",
" return left_most_node(node.right)\n", " # We reached the root, the original input node\n",
" else:\n", " # must be the largest element in the tree.\n",
" parent = node.parent\n", " return None"
" while parent is not None and parent.left is not node:\n",
" node = node.parent\n",
" parent = node.parent\n",
" if parent is None:\n",
" # We reached the root, the original input node\n",
" # must be the largest element in the tree.\n",
" return None\n",
" return parent.data"
] ]
}, },
{ {
@@ -168,28 +167,31 @@
"\n", "\n",
" @raises(Exception)\n", " @raises(Exception)\n",
" def test_bst_successor_empty(self):\n", " def test_bst_successor_empty(self):\n",
" bst_successor(None)\n", " bst_successor = BstSuccessor()\n",
" bst_successor.get_next(None)\n",
"\n", "\n",
" def test_bst_successor(self):\n", " def test_bst_successor(self):\n",
" nodes = {}\n", " nodes = {}\n",
" node = Node(5)\n", " node = Node(5)\n",
" nodes[5] = node\n", " nodes[5] = node\n",
" nodes[3] = insert(node, 3)\n", " bst = Bst(nodes[5])\n",
" nodes[8] = insert(node, 8)\n", " nodes[3] = bst.insert(3)\n",
" nodes[2] = insert(node, 2)\n", " nodes[8] = bst.insert(8)\n",
" nodes[4] = insert(node, 4)\n", " nodes[2] = bst.insert(2)\n",
" nodes[6] = insert(node, 6)\n", " nodes[4] = bst.insert(4)\n",
" nodes[12] = insert(node, 12)\n", " nodes[6] = bst.insert(6)\n",
" nodes[1] = insert(node, 1)\n", " nodes[12] = bst.insert(12)\n",
" nodes[7] = insert(node, 7)\n", " nodes[1] = bst.insert(1)\n",
" nodes[10] = insert(node, 10)\n", " nodes[7] = bst.insert(7)\n",
" nodes[15] = insert(node, 15)\n", " nodes[10] = bst.insert(10)\n",
" nodes[9] = insert(node, 9)\n", " nodes[15] = bst.insert(15)\n",
" nodes[9] = bst.insert(9)\n",
"\n", "\n",
" assert_equal(bst_successor(nodes[4]), 5)\n", " bst_successor = BstSuccessor()\n",
" assert_equal(bst_successor(nodes[5]), 6)\n", " assert_equal(bst_successor.get_next(nodes[4]), 5)\n",
" assert_equal(bst_successor(nodes[8]), 9)\n", " assert_equal(bst_successor.get_next(nodes[5]), 6)\n",
" assert_equal(bst_successor(nodes[15]), None)\n", " assert_equal(bst_successor.get_next(nodes[8]), 9)\n",
" assert_equal(bst_successor.get_next(nodes[15]), None)\n",
"\n", "\n",
" print('Success: test_bst_successor')\n", " print('Success: test_bst_successor')\n",
"\n", "\n",

35
graphs_trees/bst_successor/test_bst_successor.py
View File

@@ -6,28 +6,31 @@ class TestBstSuccessor(object):
@raises(Exception) @raises(Exception)
def test_bst_successor_empty(self): def test_bst_successor_empty(self):
bst_successor(None) bst_successor = BstSuccessor()
bst_successor.get_next(None)
def test_bst_successor(self): def test_bst_successor(self):
nodes = {} nodes = {}
node = Node(5) node = Node(5)
nodes[5] = node nodes[5] = node
nodes[3] = insert(node, 3) bst = Bst(nodes[5])
nodes[8] = insert(node, 8) nodes[3] = bst.insert(3)
nodes[2] = insert(node, 2) nodes[8] = bst.insert(8)
nodes[4] = insert(node, 4) nodes[2] = bst.insert(2)
nodes[6] = insert(node, 6) nodes[4] = bst.insert(4)
nodes[12] = insert(node, 12) nodes[6] = bst.insert(6)
nodes[1] = insert(node, 1) nodes[12] = bst.insert(12)
nodes[7] = insert(node, 7) nodes[1] = bst.insert(1)
nodes[10] = insert(node, 10) nodes[7] = bst.insert(7)
nodes[15] = insert(node, 15) nodes[10] = bst.insert(10)
nodes[9] = insert(node, 9) nodes[15] = bst.insert(15)
nodes[9] = bst.insert(9)
assert_equal(bst_successor(nodes[4]), 5) bst_successor = BstSuccessor()
assert_equal(bst_successor(nodes[5]), 6) assert_equal(bst_successor.get_next(nodes[4]), 5)
assert_equal(bst_successor(nodes[8]), 9) assert_equal(bst_successor.get_next(nodes[5]), 6)
assert_equal(bst_successor(nodes[15]), None) assert_equal(bst_successor.get_next(nodes[8]), 9)
assert_equal(bst_successor.get_next(nodes[15]), None)
print('Success: test_bst_successor') print('Success: test_bst_successor')

20
graphs_trees/tree_bfs/bfs_challenge.ipynb
View File

@@ -87,9 +87,11 @@
}, },
"outputs": [], "outputs": [],
"source": [ "source": [
"def bfs(self, visit_func):\n", "class BstBfs(Bst):\n",
" # TODO: Implement me\n", "\n",
" pass" " def bfs(self, visit_func):\n",
" # TODO: Implement me\n",
" pass"
] ]
}, },
{ {
@@ -128,12 +130,12 @@
" self.results = Results()\n", " self.results = Results()\n",
"\n", "\n",
" def test_bfs(self):\n", " def test_bfs(self):\n",
" node = Node(5)\n", " bst = BstBfs(Node(5))\n",
" insert(node, 2)\n", " bst.insert(2)\n",
" insert(node, 8)\n", " bst.insert(8)\n",
" insert(node, 1)\n", " bst.insert(1)\n",
" insert(node, 3)\n", " bst.insert(3)\n",
" bfs(node, self.results.add_result)\n", " bst.bfs(self.results.add_result)\n",
" assert_equal(str(self.results), '[5, 2, 8, 1, 3]')\n", " assert_equal(str(self.results), '[5, 2, 8, 1, 3]')\n",
"\n", "\n",
" print('Success: test_bfs')\n", " print('Success: test_bfs')\n",

36
graphs_trees/tree_bfs/bfs_solution.ipynb
View File

@@ -97,16 +97,20 @@
"from collections import deque\n", "from collections import deque\n",
"\n", "\n",
"\n", "\n",
"def bfs(root, visit_func):\n", "class BstBfs(Bst):\n",
" queue = deque()\n", "\n",
" queue.append(root)\n", " def bfs(self, visit_func):\n",
" while queue:\n", " if self.root is None:\n",
" node = queue.popleft()\n", " raise Exception('root is None')\n",
" visit_func(node)\n", " queue = deque()\n",
" if node.left is not None:\n", " queue.append(self.root)\n",
" queue.append(node.left)\n", " while queue:\n",
" if node.right is not None:\n", " node = queue.popleft()\n",
" queue.append(node.right)" " visit_func(node)\n",
" if node.left is not None:\n",
" queue.append(node.left)\n",
" if node.right is not None:\n",
" queue.append(node.right)"
] ]
}, },
{ {
@@ -153,12 +157,12 @@
" self.results = Results()\n", " self.results = Results()\n",
"\n", "\n",
" def test_bfs(self):\n", " def test_bfs(self):\n",
" node = Node(5)\n", " bst = BstBfs(Node(5))\n",
" insert(node, 2)\n", " bst.insert(2)\n",
" insert(node, 8)\n", " bst.insert(8)\n",
" insert(node, 1)\n", " bst.insert(1)\n",
" insert(node, 3)\n", " bst.insert(3)\n",
" bfs(node, self.results.add_result)\n", " bst.bfs(self.results.add_result)\n",
" assert_equal(str(self.results), '[5, 2, 8, 1, 3]')\n", " assert_equal(str(self.results), '[5, 2, 8, 1, 3]')\n",
"\n", "\n",
" print('Success: test_bfs')\n", " print('Success: test_bfs')\n",

12
graphs_trees/tree_bfs/test_bfs.py
View File

@@ -7,12 +7,12 @@ class TestBfs(object):
self.results = Results() self.results = Results()
def test_bfs(self): def test_bfs(self):
node = Node(5) bst = BstBfs(Node(5))
insert(node, 2) bst.insert(2)
insert(node, 8) bst.insert(8)
insert(node, 1) bst.insert(1)
insert(node, 3) bst.insert(3)
bfs(node, self.results.add_result) bst.bfs(self.results.add_result)
assert_equal(str(self.results), '[5, 2, 8, 1, 3]') assert_equal(str(self.results), '[5, 2, 8, 1, 3]')
print('Success: test_bfs') print('Success: test_bfs')

48
graphs_trees/tree_dfs/dfs_challenge.ipynb
View File

@@ -99,17 +99,19 @@
}, },
"outputs": [], "outputs": [],
"source": [ "source": [
"def in_order_traversal(node, visit_func):\n", "class BstDfs(Bst):\n",
"\n",
" def in_order_traversal(self, node, visit_func):\n",
" # TODO: Implement me\n", " # TODO: Implement me\n",
" pass\n", " pass\n",
"\n", "\n",
"def pre_order_traversal(node, visit_func):\n", " def pre_order_traversal(self, node, visit_func):\n",
" # TODO: Implement me\n", " # TODO: Implement me\n",
" pass\n", " pass\n",
"\n", "\n",
"def post_order_traversal(node, visit_func):\n", " def post_order_traversal(self,node, visit_func):\n",
" # TODO: Implement me\n", " # TODO: Implement me\n",
" pass" " pass"
] ]
}, },
{ {
@@ -148,39 +150,39 @@
" self.results = Results()\n", " self.results = Results()\n",
"\n", "\n",
" def test_dfs(self):\n", " def test_dfs(self):\n",
" node = Node(5)\n", " bst = BstDfs(Node(5))\n",
" insert(node, 2)\n", " bst.insert(2)\n",
" insert(node, 8)\n", " bst.insert(8)\n",
" insert(node, 1)\n", " bst.insert(1)\n",
" insert(node, 3)\n", " bst.insert(3)\n",
"\n", "\n",
" in_order_traversal(node, self.results.add_result)\n", " bst.in_order_traversal(bst.root, self.results.add_result)\n",
" assert_equal(str(self.results), \"[1, 2, 3, 5, 8]\")\n", " assert_equal(str(self.results), \"[1, 2, 3, 5, 8]\")\n",
" self.results.clear_results()\n", " self.results.clear_results()\n",
"\n", "\n",
" pre_order_traversal(node, self.results.add_result)\n", " bst.pre_order_traversal(bst.root, self.results.add_result)\n",
" assert_equal(str(self.results), \"[5, 2, 1, 3, 8]\")\n", " assert_equal(str(self.results), \"[5, 2, 1, 3, 8]\")\n",
" self.results.clear_results()\n", " self.results.clear_results()\n",
"\n", "\n",
" post_order_traversal(node, self.results.add_result)\n", " bst.post_order_traversal(bst.root, self.results.add_result)\n",
" assert_equal(str(self.results), \"[1, 3, 2, 8, 5]\")\n", " assert_equal(str(self.results), \"[1, 3, 2, 8, 5]\")\n",
" self.results.clear_results()\n", " self.results.clear_results()\n",
"\n", "\n",
" node = Node(1)\n", " bst = BstDfs(Node(1))\n",
" insert(node, 2)\n", " bst.insert(2)\n",
" insert(node, 3)\n", " bst.insert(3)\n",
" insert(node, 4)\n", " bst.insert(4)\n",
" insert(node, 5)\n", " bst.insert(5)\n",
"\n", "\n",
" in_order_traversal(node, self.results.add_result)\n", " bst.in_order_traversal(bst.root, self.results.add_result)\n",
" assert_equal(str(self.results), \"[1, 2, 3, 4, 5]\")\n", " assert_equal(str(self.results), \"[1, 2, 3, 4, 5]\")\n",
" self.results.clear_results()\n", " self.results.clear_results()\n",
"\n", "\n",
" pre_order_traversal(node, self.results.add_result)\n", " bst.pre_order_traversal(bst.root, self.results.add_result)\n",
" assert_equal(str(self.results), \"[1, 2, 3, 4, 5]\")\n", " assert_equal(str(self.results), \"[1, 2, 3, 4, 5]\")\n",
" self.results.clear_results()\n", " self.results.clear_results()\n",
"\n", "\n",
" post_order_traversal(node, self.results.add_result)\n", " bst.post_order_traversal(bst.root, self.results.add_result)\n",
" assert_equal(str(self.results), \"[5, 4, 3, 2, 1]\")\n", " assert_equal(str(self.results), \"[5, 4, 3, 2, 1]\")\n",
"\n", "\n",
" print('Success: test_dfs')\n", " print('Success: test_dfs')\n",

64
graphs_trees/tree_dfs/dfs_solution.ipynb
View File

@@ -132,23 +132,25 @@
}, },
"outputs": [], "outputs": [],
"source": [ "source": [
"def in_order_traversal(node, visit_func):\n", "class BstDfs(Bst):\n",
" if node is not None:\n",
" in_order_traversal(node.left, visit_func)\n",
" visit_func(node)\n",
" in_order_traversal(node.right, visit_func)\n",
"\n", "\n",
"def pre_order_traversal(node, visit_func):\n", " def in_order_traversal(self, node, visit_func):\n",
" if node is not None:\n", " if node is not None:\n",
" visit_func(node)\n", " self.in_order_traversal(node.left, visit_func)\n",
" pre_order_traversal(node.left, visit_func)\n", " visit_func(node)\n",
" pre_order_traversal(node.right, visit_func)\n", " self.in_order_traversal(node.right, visit_func)\n",
"\n", "\n",
"def post_order_traversal(node, visit_func):\n", " def pre_order_traversal(self, node, visit_func):\n",
" if node is not None:\n", " if node is not None:\n",
" post_order_traversal(node.left, visit_func)\n", " visit_func(node)\n",
" post_order_traversal(node.right, visit_func)\n", " self.pre_order_traversal(node.left, visit_func)\n",
" visit_func(node)" " self.pre_order_traversal(node.right, visit_func)\n",
"\n",
" def post_order_traversal(self, node, visit_func):\n",
" if node is not None:\n",
" self.post_order_traversal(node.left, visit_func)\n",
" self.post_order_traversal(node.right, visit_func)\n",
" visit_func(node)"
] ]
}, },
{ {
@@ -195,39 +197,39 @@
" self.results = Results()\n", " self.results = Results()\n",
"\n", "\n",
" def test_dfs(self):\n", " def test_dfs(self):\n",
" node = Node(5)\n", " bst = BstDfs(Node(5))\n",
" insert(node, 2)\n", " bst.insert(2)\n",
" insert(node, 8)\n", " bst.insert(8)\n",
" insert(node, 1)\n", " bst.insert(1)\n",
" insert(node, 3)\n", " bst.insert(3)\n",
"\n", "\n",
" in_order_traversal(node, self.results.add_result)\n", " bst.in_order_traversal(bst.root, self.results.add_result)\n",
" assert_equal(str(self.results), \"[1, 2, 3, 5, 8]\")\n", " assert_equal(str(self.results), \"[1, 2, 3, 5, 8]\")\n",
" self.results.clear_results()\n", " self.results.clear_results()\n",
"\n", "\n",
" pre_order_traversal(node, self.results.add_result)\n", " bst.pre_order_traversal(bst.root, self.results.add_result)\n",
" assert_equal(str(self.results), \"[5, 2, 1, 3, 8]\")\n", " assert_equal(str(self.results), \"[5, 2, 1, 3, 8]\")\n",
" self.results.clear_results()\n", " self.results.clear_results()\n",
"\n", "\n",
" post_order_traversal(node, self.results.add_result)\n", " bst.post_order_traversal(bst.root, self.results.add_result)\n",
" assert_equal(str(self.results), \"[1, 3, 2, 8, 5]\")\n", " assert_equal(str(self.results), \"[1, 3, 2, 8, 5]\")\n",
" self.results.clear_results()\n", " self.results.clear_results()\n",
"\n", "\n",
" node = Node(1)\n", " bst = BstDfs(Node(1))\n",
" insert(node, 2)\n", " bst.insert(2)\n",
" insert(node, 3)\n", " bst.insert(3)\n",
" insert(node, 4)\n", " bst.insert(4)\n",
" insert(node, 5)\n", " bst.insert(5)\n",
"\n", "\n",
" in_order_traversal(node, self.results.add_result)\n", " bst.in_order_traversal(bst.root, self.results.add_result)\n",
" assert_equal(str(self.results), \"[1, 2, 3, 4, 5]\")\n", " assert_equal(str(self.results), \"[1, 2, 3, 4, 5]\")\n",
" self.results.clear_results()\n", " self.results.clear_results()\n",
"\n", "\n",
" pre_order_traversal(node, self.results.add_result)\n", " bst.pre_order_traversal(bst.root, self.results.add_result)\n",
" assert_equal(str(self.results), \"[1, 2, 3, 4, 5]\")\n", " assert_equal(str(self.results), \"[1, 2, 3, 4, 5]\")\n",
" self.results.clear_results()\n", " self.results.clear_results()\n",
"\n", "\n",
" post_order_traversal(node, self.results.add_result)\n", " bst.post_order_traversal(bst.root, self.results.add_result)\n",
" assert_equal(str(self.results), \"[5, 4, 3, 2, 1]\")\n", " assert_equal(str(self.results), \"[5, 4, 3, 2, 1]\")\n",
"\n", "\n",
" print('Success: test_dfs')\n", " print('Success: test_dfs')\n",

32
graphs_trees/tree_dfs/test_dfs.py
View File

@@ -7,39 +7,39 @@ class TestDfs(object):
self.results = Results() self.results = Results()
def test_dfs(self): def test_dfs(self):
node = Node(5) bst = BstDfs(Node(5))
insert(node, 2) bst.insert(2)
insert(node, 8) bst.insert(8)
insert(node, 1) bst.insert(1)
insert(node, 3) bst.insert(3)
in_order_traversal(node, self.results.add_result) bst.in_order_traversal(bst.root, self.results.add_result)
assert_equal(str(self.results), "[1, 2, 3, 5, 8]") assert_equal(str(self.results), "[1, 2, 3, 5, 8]")
self.results.clear_results() self.results.clear_results()
pre_order_traversal(node, self.results.add_result) bst.pre_order_traversal(bst.root, self.results.add_result)
assert_equal(str(self.results), "[5, 2, 1, 3, 8]") assert_equal(str(self.results), "[5, 2, 1, 3, 8]")
self.results.clear_results() self.results.clear_results()
post_order_traversal(node, self.results.add_result) bst.post_order_traversal(bst.root, self.results.add_result)
assert_equal(str(self.results), "[1, 3, 2, 8, 5]") assert_equal(str(self.results), "[1, 3, 2, 8, 5]")
self.results.clear_results() self.results.clear_results()
node = Node(1) bst = BstDfs(Node(1))
insert(node, 2) bst.insert(2)
insert(node, 3) bst.insert(3)
insert(node, 4) bst.insert(4)
insert(node, 5) bst.insert(5)
in_order_traversal(node, self.results.add_result) bst.in_order_traversal(bst.root, self.results.add_result)
assert_equal(str(self.results), "[1, 2, 3, 4, 5]") assert_equal(str(self.results), "[1, 2, 3, 4, 5]")
self.results.clear_results() self.results.clear_results()
pre_order_traversal(node, self.results.add_result) bst.pre_order_traversal(bst.root, self.results.add_result)
assert_equal(str(self.results), "[1, 2, 3, 4, 5]") assert_equal(str(self.results), "[1, 2, 3, 4, 5]")
self.results.clear_results() self.results.clear_results()
post_order_traversal(node, self.results.add_result) bst.post_order_traversal(bst.root, self.results.add_result)
assert_equal(str(self.results), "[5, 4, 3, 2, 1]") assert_equal(str(self.results), "[5, 4, 3, 2, 1]")
print('Success: test_dfs') print('Success: test_dfs')

12
graphs_trees/tree_height/height.py
View File

@@ -1,5 +1,7 @@
def height(node): class BstHeight(Bst):
if node is None:
return 0 def height(self, node):
return 1 + max(height(node.left), if node is None:
height(node.right)) return 0
return 1 + max(self.height(node.left),
self.height(node.right))

22
graphs_trees/tree_height/height_challenge.ipynb
View File

@@ -88,9 +88,11 @@
}, },
"outputs": [], "outputs": [],
"source": [ "source": [
"def height(node):\n", "class BstHeight(Bst):\n",
" # TODO: Implement me\n", "\n",
" pass" " def height(self, node):\n",
" # TODO: Implement me\n",
" pass"
] ]
}, },
{ {
@@ -122,13 +124,13 @@
"class TestHeight(object):\n", "class TestHeight(object):\n",
"\n", "\n",
" def test_height(self):\n", " def test_height(self):\n",
" root = Node(5)\n", " bst = BstHeight(Node(5))\n",
" assert_equal(height(root), 1)\n", " assert_equal(bst.height(bst.root), 1)\n",
" insert(root, 2)\n", " bst.insert(2)\n",
" insert(root, 8)\n", " bst.insert(8)\n",
" insert(root, 1)\n", " bst.insert(1)\n",
" insert(root, 3)\n", " bst.insert(3)\n",
" assert_equal(height(root), 3)\n", " assert_equal(bst.height(bst.root), 3)\n",
"\n", "\n",
" print('Success: test_height')\n", " print('Success: test_height')\n",
"\n", "\n",

50
graphs_trees/tree_height/height_solution.ipynb
View File

@@ -91,33 +91,15 @@
"metadata": { "metadata": {
"collapsed": false "collapsed": false
}, },
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Overwriting height.py\n"
]
}
],
"source": [
"%%writefile height.py\n",
"def height(node):\n",
" if node is None:\n",
" return 0\n",
" return 1 + max(height(node.left), \n",
" height(node.right))"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {
"collapsed": true
},
"outputs": [], "outputs": [],
"source": [ "source": [
"%run height.py" "class BstHeight(Bst):\n",
"\n",
" def height(self, node):\n",
" if node is None:\n",
" return 0\n",
" return 1 + max(self.height(node.left),\n",
" self.height(node.right))"
] ]
}, },
{ {
@@ -129,7 +111,7 @@
}, },
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 4, "execution_count": 3,
"metadata": { "metadata": {
"collapsed": false "collapsed": false
}, },
@@ -150,13 +132,13 @@
"class TestHeight(object):\n", "class TestHeight(object):\n",
"\n", "\n",
" def test_height(self):\n", " def test_height(self):\n",
" root = Node(5)\n", " bst = BstHeight(Node(5))\n",
" assert_equal(height(root), 1)\n", " assert_equal(bst.height(bst.root), 1)\n",
" insert(root, 2)\n", " bst.insert(2)\n",
" insert(root, 8)\n", " bst.insert(8)\n",
" insert(root, 1)\n", " bst.insert(1)\n",
" insert(root, 3)\n", " bst.insert(3)\n",
" assert_equal(height(root), 3)\n", " assert_equal(bst.height(bst.root), 3)\n",
"\n", "\n",
" print('Success: test_height')\n", " print('Success: test_height')\n",
"\n", "\n",
@@ -172,7 +154,7 @@
}, },
{ {
"cell_type": "code", "cell_type": "code",
"execution_count": 5, "execution_count": 4,
"metadata": { "metadata": {
"collapsed": false "collapsed": false
}, },

14
graphs_trees/tree_height/test_height.py
View File

@@ -4,13 +4,13 @@ from nose.tools import assert_equal
class TestHeight(object): class TestHeight(object):
def test_height(self): def test_height(self):
root = Node(5) bst = BstHeight(Node(5))
assert_equal(height(root), 1) assert_equal(bst.height(bst.root), 1)
insert(root, 2) bst.insert(2)
insert(root, 8) bst.insert(8)
insert(root, 1) bst.insert(1)
insert(root, 3) bst.insert(3)
assert_equal(height(root), 3) assert_equal(bst.height(bst.root), 3)
print('Success: test_height') print('Success: test_height')