def test_twoelements_notdistinct(self):
"""Test when there are two elements, but they're the same."""
root = Node(key=42)
right = Node(key=42)
root.right = right
self.assertEqual(ffk_it(root, 42), root)
self.assertEqual(ffk_rec(root, 42), root)
def test_twoelements_distinct(self):
"""Test when there's two distinct elements."""
root = Node(key=42)
right = Node(key=50)
root.right = right
self.assertEqual(ffk_it(root, 42), root)
self.assertEqual(ffk_rec(root, 50), right)
def test_threeelements_notdistinct(self):
"""Test when there's three elements, but they're not all distinct."""
root = Node(key=42)
left = Node(key=19)
right = Node(key=42)
root.right = right
root.left = left
self.assertEqual(fltk(root, 42), None)
self.assertEqual(fltk(root, 19), root)
def test_threeelements_distinct(self):
"""Test when there's three distinct elements."""
root = Node(key=42)
left = Node(key=19)
right = Node(key=52)
root.right = right
root.left = left
self.assertEqual(fltk(root, 42), right)
self.assertEqual(fltk(root, 19), root)
self.assertEqual(fltk(root, 52), None)
def test_threeelements(self):
"""Tests when there are three elements."""
root = Node(key=42)
left = Node(key=0, parent=root)
right = Node(key=50, parent=root)
root.left = left
root.right = right
self.assertEqual(findsuccessor(left), root)
self.assertEqual(findsuccessor(root), right)
self.assertEqual(findsuccessor(right), None)
def test_threeelements_split(self):
"""Tests three-element tree where root has two children."""
root = Node(key=42)
left = Node(key=50)
right = Node(key=100)
root.left = left
root.right = right
self.assertTrue(findk(root, 42))
self.assertTrue(findk(root, 50))
self.assertTrue(findk(root, 100))
def test_threeelements_chain(self):
"""Tests three-element tree where root has one child."""
root = Node(key=42)
left = Node(key=50)
right = Node(key=100)
root.left = left
left.right = right
self.assertTrue(findk(root, 42))
self.assertTrue(findk(root, 50))
self.assertTrue(findk(root, 100))
def test_threeelements_chain(self):
"""Tests three-element tree where root has one child."""
root = Node(key=42)
left = Node(key=10)
right = Node(key=28)
root.left = left
left.right = right
ll = BSTtoLL(root)
sort, count = issorted(ll)
self.assertTrue(sort)
self.assertEqual(count, 3)
def test_testbookexample(self):
"""Tests an array containing keys from the tree from text."""
array = [
2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53]
bst = atoBST(array)
self.assertTrue(verify(bst))
self.assertTrue(Node.getheight(bst) <= ceil(log(len(array), 2)))
def test_oneelementss(self):
"""Tests a linked list with only one key."""
array = [42, 42, 42, 42, 42, 42, 42, 42]
linkedlist = arraytolinkedlist(array)
bst = lltoBST(linkedlist)
self.assertTrue(verify(bst))
self.assertTrue(Node.getheight(bst) <= ceil(log(len(array), 2)))
def test_testbookexample(self):
"""Tests the tree from text."""
C = Node(key=3, left=Node(key=2), right=Node(key=5))
G = Node(key=17, left=Node(key=13))
F = Node(key=11, right=G)
B = Node(key=7, left=C, right=F)
L = Node(key=29, right=Node(key=31))
K = Node(key=37, left=L, right=Node(key=41))
J = Node(key=23, right=K)
O = Node(key=47, right=Node(key=53))
I = Node(key=43, left=J, right=O)
A = Node(key=19, left=B, right=I)
self.assertEqual(Node.getheight(A), 5)
self.assertEqual(Node.getheight(K), 2)
self.assertEqual(Node.getheight(B), 3)
def test_threeelements_chain(self):
"""Tests three-element tree where root has one child."""
root = Node(key=42)
left = Node(key=10)
right = Node(key=28)
root.left = left
left.right = right
self.assertEqual(Node.getheight(root), 2)
self.assertEqual(Node.getheight(left), 1)
self.assertEqual(Node.getheight(right), 0)
def test_singleelement(self):
"""Tests a single-element tree."""
array = [42]
bst = atoBST(array)
self.assertTrue(verify(bst))
self.assertTrue(Node.getheight(bst) <= ceil(log(len(array), 2)))
def test_null(self):
"""Tests a null linked list."""
linkedlist = None
bst = lltoBST(linkedlist)
self.assertTrue(verify(bst))
self.assertTrue(Node.getheight(bst) == -1)
def test_threeelements_split(self):
"""Tests three-element tree where root has two children."""
root = Node(key=42, left=Node(key=10), right=Node(key=100))
self.assertEqual(Node.getheight(root), 1)
def test_singleelement(self):
"""Tests a linked list with one element."""
linkedlist = Node(key=42)
bst = lltoBST(linkedlist)
self.assertTrue(verify(bst))
self.assertTrue(Node.getheight(bst) <= ceil(log(1, 2)))
def test_threeelements(self):
"""Tests a linked list with three elements."""
linkedlist = Node(key=10, right=Node(key=42, right=Node(key=100)))
bst = lltoBST(linkedlist)
self.assertTrue(verify(bst))
self.assertTrue(Node.getheight(bst) <= ceil(log(3, 2)))
def test_textbooktree(self):
"""Tests the tree provided by the textbook."""
A = Node(key=19)
B = Node(key=7, parent=A)
I = Node(key=43, parent=A)
A.left = B
A.right = I
C = Node(key=3, parent=B)
F = Node(key=11, parent=B)
B.left = C
B.right = F
D = Node(key=2, parent=C)
E = Node(key=5, parent=C)
C.left = D
C.right = E
G = Node(key=17, parent=F)
F.right = G
H = Node(key=13, parent=G)
G.left = H
J = Node(23, parent=I)
O = Node(47, parent=I)
I.left = J
I.right = O
K = Node(key=37, parent=J)
J.right = K
L = Node(key=29, parent=K)
N = Node(key=41, parent=K)
K.left = L
K.right = N
M = Node(key=31, parent=L)
L.right = M
P = Node(key=53, parent=O)
O.right = P
self.assertEqual(findsuccessor(P), None)
self.assertEqual(findsuccessor(G), A)
self.assertEqual(findsuccessor(A), J)
def test_null(self):
"""Tests a null tree."""
array = []
bst = atoBST(array)
self.assertTrue(verify(bst))
self.assertTrue(Node.getheight(bst) == -1)
def test_oneelementss(self):
"""Tests an array with only one key."""
array = [42, 42, 42, 42, 42, 42, 42, 42]
bst = atoBST(array)
self.assertTrue(verify(bst))
self.assertTrue(Node.getheight(bst) <= ceil(log(len(array), 2)))
def test_singleelement(self):
"""Tests a single-element tree."""
root = Node(key=42)
self.assertEqual(Node.getheight(root), 0)
def test_threeelements(self):
"""Tests 3-element array."""
array = [10, 42, 100]
bst = atoBST(array)
self.assertTrue(verify(bst))
self.assertTrue(Node.getheight(bst) <= ceil(log(len(array), 2)))
