def test_delete_head_only():
"""Test deleteing a one node head."""
from bst import BST
b = BST([20])
assert b.contains(20) is True
b.delete(20)
assert b.contains(20) is False
def test_contains():
bst = BST()
for i in range(1, 11):
bst.insert(i)
assert bst.contains(1)
assert bst.contains(5)
assert not bst.contains(15)
class SymbolGraph:
def __init__(self, stream, sp, cls_g=Graph):
self.st = ST() # {key: i}
for line in open(stream):
for key in line.strip().split(sp):
if not self.st.contains(key):
self.st.put(key, self.st.size())
self.keys = [""] * self.st.size() # reverse index, {i: key}
for key in self.st:
self.keys[self.st.get(key)] = key
self.G = cls_g(self.st.size()) # use int i as vertex
for line in open(stream):
a = line.strip().split(sp)
v = self.st.get(a[0])
for i in range(1, len(a)):
self.G.add_edge(v, self.st.get(a[i]))
def contains(self, s):
return self.st.contains(s)
def index(self, s):
return self.st.get(s)
def name(self, v):
return self.keys[v]
def graph(self):
return self.G
def test_contains():
bst = BST()
for i in range(1,11):
bst.insert(i)
assert bst.contains(1)
assert bst.contains(5)
assert not bst.contains(15)
def test_delete_head_one_right_child():
"""Test deleting a head with one right child."""
from bst import BST
b = BST([20])
b.insert(22)
assert b.contains(20) is True
b.delete(20)
assert b.contains(20) is False
assert b.top.value == 22
def test_contains():
tree = BST()
tree.insert(0)
tree.insert(1)
tree.insert(-1)
tree.insert(2)
tree.insert(-2)
assert tree.contains(-1)
assert tree.contains(0)
assert tree.contains(4) is False
def test_contains():
btree = BST()
btree.insert(3)
btree.insert(2)
btree.insert(5)
btree.insert(4)
btree.insert(1)
assert btree.contains(5) is True
assert btree.contains(1) is True
assert btree.contains(10) is False
class BSTTestCase(unittest.TestCase):
def setUp(self):
self.tree = BST()
self.nodes = {5: 'five', 7: 'seven', 2: 'two', 3: 'three', 1: 'one', 8: 'eight'}
for k, v in self.nodes.items():
self.tree.put(k,v)
def tearDown(self):
del self.tree
del self.nodes
def testPutGet(self):
for k, v in self.nodes.items():
self.assertEqual(v, self.tree.get(k))
for k in [4,6,9]:
self.assertIsNone(self.tree.get(k))
def testLen(self):
self.assertEqual(6, len(self.tree))
def testMinKey(self):
self.assertEqual(1, self.tree.minKey())
def testMin(self):
self.assertTupleEqual((1, 'one'), self.tree.min())
def testMaxKey(self):
self.assertEqual(8, self.tree.maxKey())
def testMax(self):
self.assertTupleEqual((8, 'eight'), self.tree.max())
def testIsEmpty(self):
self.assertFalse(self.tree.isEmpty())
self.assertTrue(BST().isEmpty())
def testItems(self):
self.assertSequenceEqual(sorted(self.nodes.items()), list(self.tree.items()))
def testKeys(self):
self.assertSequenceEqual(sorted(self.nodes.keys()), list(self.tree.keys()))
def testContains(self):
self.assertTrue(self.tree.contains(8))
self.assertFalse(self.tree.contains(13))
def testKeysBetween(self):
self.assertSequenceEqual([2,3,5], list(self.tree.keys_between(2, 6)))
def testNumKeysBetween(self):
# self.nodes = {5: 'five', 7: 'seven', 2: 'two', 3: 'three', 1: 'one', 8: 'eight'}
self.assertEqual(4, self.tree.num_between(3, 8))
def testRank(self):
self.assertEqual(2, self.tree.rank(3))
def test_delete_head_two_children():
"""Test deleting a head with two children."""
from bst import BST
b = BST([20])
b.insert(18)
b.insert(22)
assert b.contains(20) is True
b.delete(20)
assert b.contains(20) is False
assert b.top.value == 22
assert b.top.left.value == 18
assert b.top.right is None
def test_general_functions(self): # XX
print("Running test_general_functions")
# Add a number of elements to at least prevent some possible toy-example working out
h = BST([50, 70, 80, 60, 55, 67, 90, 57, 20, 10, 15, 0])
self.assertEqual(h.find_min(), 0)
self.assertEqual(h.find_max(), 90)
self.assertFalse(h.is_empty())
n = h.search(67)
m = h.search(99)
self.assertTrue(isinstance(n, Node))
self.assertEqual(n.get_key(), 67)
self.assertEqual(m, None)
self.assertTrue(h.contains(67))
self.assertFalse(h.contains(100))
def test_delete_one_item():
from bst import BST
bst = BST()
bst.insert(42)
bst.delete(42)
assert not bst._search(42)
assert not bst.contains(42)
def test_contains_returns_false_if_value_not_in_bst(val):
"""Test contains returns false if value is not in the tree."""
from bst import BST
t = BST()
t.insert(3)
t.insert(1)
t.insert(5)
assert t.contains(23) is False
def test_contains():
"""contains(val) should return True if val is in the BST, False if not."""
bintree = BST()
with pytest.raises(TypeError):
bintree.insert()
with pytest.raises(TypeError):
bintree.insert(1, 2)
# Will accept any value including None; behavior is on the user
assert bintree.contains(None) is False
assert bintree.contains(1) is False
bintree.insert(1)
assert bintree.contains(1) is True
for i in xrange(-5, 5):
bintree.insert(i)
for i in xrange(-5, 5):
assert bintree.contains(i) is True
assert bintree.contains(None) is False
def test_delete_one_child():
"""delete(self, val) should remove val from the tree if present,
if not present it should do nothing. Return None in all cases"""
bintree = BST()
bintree.insert(5)
bintree.insert(3)
bintree.insert(7)
bintree.insert(2)
bintree.insert(4)
bintree.insert(1)
bintree.insert(9)
bintree.insert(10)
# 5
# / \
# 3 7
# /\ \
# 2 4 9
# | |
# 1 10
assert bintree.size() == 8
assert bintree.delete(7) is None
# 5
# / \
# 3 9
# /\ \
# 2 4 10
# |
# 1
assert bintree.size() == 7
assert not bintree.contains(7)
assert bintree.contains(9)
assert bintree.contains(10)
assert bintree.balance() == 1
assert bintree.delete(2) is None
# 5
# / \
# 3 9
# /\ \
# 1 4 10
assert bintree.size() == 6
assert not bintree.contains(2)
assert bintree.contains(1)
assert bintree.leftchild.leftchild.value == 1
assert bintree.balance() == 0
def test_contains4():
root = Node(10)
bst = BST(root)
bst.insert(5)
bst.insert(15)
bst.insert(20)
bst.insert(0)
bst.insert(-5)
bst.insert(3)
assert bst.contains(0) == True
def test_contains2():
root = Node(10)
bst = BST(root)
bst.insert(5)
bst.insert(15)
bst.insert(20)
bst.insert(0)
bst.insert(-5)
bst.insert(3)
assert bst.contains(1) == False
def test_delete():
tree = BST()
for n in [0, 2, -2, 1, -1, 3, -3]:
tree.insert(n)
for n in [-3, -2, -1, 0, 1, 2, 3]:
assert tree.contains(n)
tree.delete(-3)
assert tree.contains(-3) is False
tree.delete(-2)
assert tree.contains(-2) is False
for n in [-1, 0, 1, 2, 3]:
assert tree.contains(n)
assert tree.size() == 5
tree.insert(5)
tree.insert(4)
tree.insert(6)
tree.delete(3)
assert tree.size() == 7
for i in [-1, 0, 1, 2, 4, 5, 6]:
assert tree.contains(i)
class BSTSet(SetBase):
def __init__(self):
self._bst = BST()
def get_size(self):
return self._bst.size()
def is_empty(self):
return self._bst.is_empty()
def add(self, e):
return self._bst.add(e)
def contains(self, e):
return self._bst.contains(e)
def remove(self, e):
return self._bst.remove(e)
def test_contains5():
root = Node(10)
bst = BST(root)
assert bst.contains(10) == True
def test_delete_root_small_bst():
"""Delete root, and replace it with replacement."""
bst = BST([10, 5, 20])
bst.delete(10)
assert not bst.contains(10)
def test_contains_empty():
'''Test contains returns false if passed an empty bst.'''
bst = BST()
assert bst.contains(1) is False
def test_iterable_passed_to_bst():
'''Test iterable can be passed to initialize BST.'''
bst = BST([1, 2, 3])
assert bst.contains(1) is True
def test_delete_leaf_node_right():
"""BST no longer has pointer to deleted leaf node."""
bst = BST([10, 5, 20])
bst.delete(20)
assert not bst.contains(20)
from bst import BST bt = BST() bt.add(12) print(bt.contains(12)) print(bt.contains(5))
# for name in names_1:
# sll.add_to_tail(name)
# for name in names_2:
# if sll.search(name):
# duplicates.append(name)
# Worked but DAMN lol!!! O(c^n)
# runtime: 32.25076985359192 seconds
# ? Using BST
# runtime: 0.17090082168579102 seconds
# O(log n)
bst = BST("")
for name in names_1:
bst.insert(name)
for name in names_2:
if bst.contains(name):
duplicates.append(name)
end_time = time.time()
print(f"{len(duplicates)} duplicates:\n\n{', '.join(duplicates)}\n\n")
print(f"runtime: {end_time - start_time} seconds")
# ---------- Stretch Goal -----------
# Python has built-in tools that allow for a very efficient approach to this problem
# What's the best time you can accomplish? Thare are no restrictions on techniques or data
# structures, but you may not import any additional libraries that you did not write yourself.
----------------------------------------------------------
Binary Search Tree improvement
efficienct of O(n log n) because:
O(log n) # Binary Search Tree
+ O(n) # Size of second file
"""
#initialize the Binary Search Tree
bst = BST('')
#traverse file line by line
for name_1 in names_1:
#insert each line into BST
bst.insert(name_1)
#traverse other file line by line
for name_2 in names_2:
#if current line value is in BST
if bst.contains(name_2):
#add value to array of duplicates
duplicates.append(name_2)
"""
runtime = .06 seconds
"""
end_time = time.time()
print (f"{len(duplicates)} duplicates:\n\n{', '.join(duplicates)}\n\n")
print (f"runtime: {end_time - start_time} seconds")
# ---------- Stretch Goal -----------
# Python has built-in tools that allow for a very efficient approach to this problem
# What's the best time you can accomplish? Thare are no restrictions on techniques or data
# structures, but you may not import any additional libraries that you did not write yourself.
def test_contains_returns_false_when_bst_empty():
"""Test empty bst returns false when contains with value is initiated."""
from bst import BST
t = BST()
assert t.contains(0) is False
def test_contains_returns_true_if_value_in_bst(val):
"""Test contains returns true if value in bst."""
from bst import BST
t = BST()
t.insert(val)
assert t.contains(val) is True
