def __init__(self, filepath=None):
if filepath is None:
filepath = "studidaten.txt"
self.filepath = filepath
self.options = {
"L": ("Alle daten löschen", self._del_all),
"Z":
("Gib das Array aus", lambda: self._print(self.unsorted_array)),
"ZN": ("Liste nach Namen anzeigen",
lambda: self._print(self.ll_by_name)),
"ZM": ("Liste nach Matrikelnummer anzeigen",
lambda: self._print(self.ll_by_matr)),
"SN":
("Studi mit bestimmtenm Namen suchen",
lambda: self._print(self._search(self.ll_by_name, _sort_name))),
"SM": ("Studi mit bestimmter Matrikelnummer suchen", lambda: self.
_print(self._search(self.ll_by_matr, _sort_matr, int))),
"N": ("Neuen Studi einfügen", self._add_new_studi),
"LN":
("Studi nach Namen löschen", lambda: self._del_search(_sort_name)),
"LM": ("Studi nache Matrikelnummer löschen",
lambda: self._del_search(_sort_matr, int)),
"MN": ("Studinamen ändern", self._modify_name),
"MM": ("Matrikelnummer ändern", self._modify_matr),
"S": ("Daten speichern", self._save),
"E": ("Programmende", exit)
}
self.unsorted_array = []
self.ll_by_name = BinarySearchTree(key=_sort_name)
self.ll_by_matr = BinarySearchTree(key=_sort_matr)
self._load()
def link(self, u, v):
if (self.is_connected(u, v)):
return False
x = self.__get_node(u)
y = self.__get_node(v)
if (x):
self.__re_root(x)
if (y):
self.__re_root(y)
utemp = BinarySearchTree().insert_new(x)
vtemp = BinarySearchTree().insert_new(y)
utemp.val = u
vtemp.val = v
# print(utemp.right , utemp.left , vtemp.right , vtemp.left)
self.__add_node(u, utemp)
self.__add_node(v, vtemp)
# print(self.NodeSet)
if (not y):
y = vtemp
BinarySearchTree().change_root(y)
utemp.right = y
y.par = utemp
utemp.update()
# print("utemp , vtemp , uright , ypar",utemp,vtemp, utemp.right , y.par)
self.__add_edge(u, v, utemp)
self.__add_edge(v, u, vtemp)
return True
pass
def test_delete(self):
tree = BinarySearchTree()
self.assertIsNone(tree.delete(1), "empty tree")
keys = random.sample(range(1000), 100)
for key in keys:
tree.put("key{}".format(key), "value{}".format(key))
for key in keys:
v = tree.delete("key{}".format(key))
self.assertEqual("value{}".format(key), v)
tree = BinarySearchTree()
for i in range(512):
tree.put(i, i * 100)
for i in range(512):
self.assertEqual(i * 100, tree.delete(i))
tree = BinarySearchTree()
for i in range(128):
tree.put(i, i * 100)
for i in reversed(range(128)):
self.assertEqual(i * 100, tree.delete(i))
for j in range(i):
self.assertEqual(j * 100, tree.get(j))
self.assertIsNone(tree.delete(0))
def __re_root(self, nn):
BinarySearchTree().change_root(nn)
if (not nn.left):
return
l = nn.left
BinarySearchTree().remove_child(l)
front = BinarySearchTree().leftmost(l)
front.left = nn
nn.par = front
front.update()
BinarySearchTree().change_root(nn)
pass
def size(self, u):
x = self.__get_node(u)
if (not x):
return 1
BinarySearchTree().change_root(x)
return (x.size) / 2 + 1
pass
def test_root_remove(self):
tree = BinarySearchTree()
tree.insert(10)
self.assertTrue(tree.remove(10))
self.assertFalse(tree.search(10))
tree.insert(10)
tree.insert(20)
self.assertTrue(tree.remove(10))
self.assertFalse(tree.search(10))
self.assertTrue(tree.search(20))
self.assertTrue(tree.remove(20))
tree.insert(10)
tree.insert(20)
tree.insert(5)
tree.insert(25)
tree.insert(11)
self.assertTrue(tree.remove(10))
self.assertEqual(tree.root.value, 11)
self.assertTrue(tree.search(5))
self.assertTrue(tree.search(20))
self.assertTrue(tree.search(25))
self.assertFalse(tree.search(10))
def test_IsEmpty(self):
tree = BinarySearchTree()
self.assertTrue(tree.isEmpty())
tree.add("Hello World!")
self.assertFalse(tree.isEmpty())
def test_put(self):
tree = BinarySearchTree()
keys = random.sample(range(1000000), 10000)
for key in keys:
tree.put(key, "value{}".format(key))
for key in keys:
self.assertTrue(tree.get(key) == "value{}".format(key))
def test_findParent_whenLookingAtLevel1_returnsRoot(self):
bst = BinarySearchTree()
bst.insert(10, bst.root)
bst.insert(9, bst.root)
bst.insert(15, bst.root)
self.assertEqual(bst.findParent(9, bst.root).value, 10)
def testSize(self):
tree = BinarySearchTree()
# Tree should look like:
# M
# J S
# B N Z
# A
# No tree
self.assertEqual(len(tree), 0)
# Layer One
tree.add("M")
self.assertEqual(len(tree), 1)
# Layer Two
tree.add("J")
self.assertEqual(len(tree), 2)
tree.add("S")
self.assertEqual(len(tree), 3)
# Layer Three
tree.add("B")
self.assertEqual(len(tree), 4)
tree.add("N")
self.assertEqual(len(tree), 5)
tree.add("Z")
self.assertEqual(len(tree), 6)
# Layer 4
tree.add("A")
self.assertEqual(len(tree), 7)
def test_findParent_whenLookingAtRoot_returnsNone(self):
bst = BinarySearchTree()
bst.insert(10, bst.root)
bst.insert(9, bst.root)
bst.insert(15, bst.root)
self.assertIsNone(bst.findParent(10, bst.root))
def testHeight(self):
tree = BinarySearchTree()
# Tree should look like:
# M
# J S
# B N Z
# A
# No tree
self.assertEqual(tree.height(), 0)
# Layer One
tree.add("M")
self.assertEqual(tree.height(), 1)
# Layer Two
tree.add("J")
self.assertEqual(tree.height(), 2)
tree.add("S")
self.assertEqual(tree.height(), 2)
# Layer Three
tree.add("B")
self.assertEqual(tree.height(), 3)
tree.add("N")
self.assertEqual(tree.height(), 3)
tree.add("Z")
self.assertEqual(tree.height(), 3)
# Layer 4
tree.add("A")
self.assertEqual(tree.height(), 4)
def test_insert_whenInsertingLowerValue_insertsAsLeftChild(self):
bst = BinarySearchTree()
bst.insert(10, bst.root)
bst.insert(5, bst.root)
self.assertEqual(len(bst), 2)
self.assertEqual(bst.root.left.value, 5)
def setUp(self):
"""
Runs before every test
:return:
"""
self.bst = BinarySearchTree()
self.bst.create_nodes_from_list(vals=[10, 15, 8, 9, 7, 13, 17, 16, 19])
def setUp(self):
self.bst = BinarySearchTree()
self.bst.put('H', 5)
self.bst.put('B', 4)
self.bst.put('K', 9)
self.bst.put('C', 2)
self.bst.put('I', -1)
self.bst.put('M', 11)
def test_delete_one_child(self):
tree = BinarySearchTree(10)
tree.insert(20)
tree.insert(17)
tree.insert(11)
tree.insert(19)
tree.deleteNode(tree, 19)
self.assertEqual(tree.toList(), [10,20, 17, 11])
def cut(self, u, v):
x = self.__get_edge(u, v)
if (not x):
return False
y = self.__get_edge(v, u)
self.__re_root(x)
BinarySearchTree().change_root(y)
while (x.par != y):
BinarySearchTree().rotate(x)
BinarySearchTree().remove_child(x)
next = BinarySearchTree().next_in_seq(y)
if (next):
temp = next.val
t = BinarySearchTree().rightmost(next)
self.__remove_edge(v, temp)
self.__add_edge(v, temp, t)
self.__remove_node(u, x)
self.__remove_node(v, y)
self.__remove_edge(u, v)
self.__remove_edge(v, u)
BinarySearchTree().delete_node(x)
BinarySearchTree().delete_node(y)
return True
pass
def test_findParent_whenLookingAtLevel2_returnsRightParentFromLevel1(self):
bst = BinarySearchTree()
bst.insert(19, bst.root)
bst.insert(15, bst.root)
bst.insert(21, bst.root)
bst.insert(11, bst.root)
bst.insert(18, bst.root)
self.assertEqual(bst.findParent(18, bst.root).value, 15)
def test_search_whenElemPresent_returnsTrue(self):
bst = BinarySearchTree()
bst.insert(10, bst.root)
bst.insert(9, bst.root)
bst.insert(15, bst.root)
#bst.inorderPrint(bst.root)
res = bst.search(15, bst.root)
self.assertTrue(res)
def test_search_whenElemNotPresent_returnsFalse(self):
bst = BinarySearchTree()
bst.insert(10, bst.root)
bst.insert(9, bst.root)
bst.insert(15, bst.root)
#bst.inorderPrint(bst.root)
self.assertFalse(bst.search(99, bst.root))
def test_find_leaf(self):
keys = {1, 2, 3}
binary_search_tree = BinarySearchTree()
for key in keys:
binary_search_tree.insert(key, key)
result = binary_search_tree.find_leaf(binary_search_tree.root)
self.assert_node_has_no_children(result)
def test_delete_two_childs(self):
tree = BinarySearchTree(10)
tree.insert(20, 0, 100, 50, 30, 17)
print("\ntest tree")
tree.printHierarchy()
print("\nDepth")
print(tree.getDepth())
tree.deleteNode(tree,20)
print("\nremoved node with data == 20")
tree.printHierarchy()
def test_Add(self):
# Add element which does not yet exist
tree = BinarySearchTree()
self.assertTrue(tree.add('A'))
# Add duplicate element
self.assertFalse(tree.add('A'))
# Add a second element which is not a duplicate
self.assertTrue(tree.add('B'))
def test_add_one_number(self):
key = "Apeldoorn"
value = 1
variable = self.create_node(key, value)
binary_search_tree = BinarySearchTree()
binary_search_tree.insert(key, value)
self.assert_root_has_correct_key_and_value(binary_search_tree.root,
variable)
self.assert_node_has_no_children(binary_search_tree.root)
def test_add_right_child(self):
key1 = 1
key2 = 2
value1 = 1
value2 = 2
binary_search_tree = BinarySearchTree()
binary_search_tree.insert(key1, value1)
binary_search_tree.insert(key2, value2)
self.assert_node_has_one_right_child(binary_search_tree.root)
def test_get(self):
tree = BinarySearchTree()
self.assertIsNone(tree.get(1), "empty tree")
keys = random.sample(range(1000), 100)
for key in keys:
tree.put("key{}".format(key), "value{}".format(key))
for _ in range(100):
index = random.randint(0, len(keys) - 1)
self.assertEqual("value{}".format(keys[index]),
tree.get("key{}".format(keys[index])))
for i in range(1001, 1100):
self.assertIsNone(tree.get("key{}".format(i)))
# tree is list
tree = BinarySearchTree()
for i in range(1000):
tree.put(i, i * 100)
for i in range(1000):
self.assertEqual(i * 100, tree.get(i))
def testRuntimeErrorPostOrder(self):
bst = BinarySearchTree("postorder")
bst.add(1)
bst.add(2)
bst.add(3)
iter(bst)
bst.add(0)
self.assertRaises(RuntimeError, next, bst)
def testRuntimeErrorRemovingLevelOrder(self):
bst = BinarySearchTree("levelorder")
bst.add(1)
bst.add(2)
bst.add(3)
iter(bst)
bst.remove(2)
self.assertRaises(RuntimeError, next, bst)
def __add_node(self, u, nn):
BinarySearchTree().change_root(nn)
if (not self.NodeSet.get(u)):
self.NodeSet[u] = set()
self.NodeSet[u].add(nn)
if (not self.IDtoNode.get(u)):
self.IDtoNode[u] = nn
if (u in self.adj_map[0] and u in self.adj_map[1]):
nn.adjacent_nodes[0] = self.adj_map[0][u]
nn.adjacent_nodes[1] = self.adj_map[1][u]
nn.update()
pass
def test_find(self):
key1 = 2
key2 = 1
key3 = 0
value1 = 1
value2 = 2
binary_search_tree = BinarySearchTree()
binary_search_tree.insert(key1, value2)
binary_search_tree.insert(key2, value1)
binary_search_tree.insert(key3, value1)
result = binary_search_tree.find(key1)
self.assert_found(key1, result)
