def test_determine_node_to_add_to_smaller_value_one_left_child_exists(
self):
bt = BinaryTree()
bt.root = Node(4)
bt.root.left_child = Node(3)
node_to_add_to = bt._determine_node_to_add_to(bt.root, 2)
self.assertEqual(bt.root.left_child, node_to_add_to)
def test_determine_node_to_add_to_larger_value_one_right_child_exists(
self):
bt = BinaryTree()
bt.root = Node(4)
bt.root.right_child = Node(8)
node_to_add_to = bt._determine_node_to_add_to(bt.root, 5)
self.assertEqual(bt.root.right_child, node_to_add_to)
def test_left_or_right_child_equal_value(self):
bt = BinaryTree()
bt.root = Node(4)
bt.root.left_child = Node(3)
bt.root.right_child = Node(7)
result = bt._left_or_right_child(bt.root, 4)
self.assertEqual(bt.root.right_child, result)
def test_structure(self):
node = Node(data='one')
second_node = Node(data='two')
third_node = Node(data='three',left=node, right=second_node)
assert third_node.data == 'three'
assert third_node.left.data == 'one'
assert third_node.right.data == 'two'
def test_delete_with_right(self):
root = Node(data=3)
root.left = Node(data=1)
root.left.right = Node(data=2)
root = self.binary_tree.delete(node=root, data=1)
assert root.left.data == 2
def test_rank_right(self):
root = Node(data=4)
root.left = Node(data=1)
root.left.right = Node(data=3)
root.right = Node(data=6)
root.right.left = Node(data=5)
assert self.binary_tree.rank(node=root, data=6) == 5
def test_lookup(self):
root = Node(data='two')
root.left = Node(data='one')
root.right = Node(data='tww')
assert self.binary_tree.lookup(node=root, data='one') is True
assert self.binary_tree.lookup(node=root, data='two') is True
assert self.binary_tree.lookup(node=root, data='tww') is True
def test_delete_with_both_children(self):
root = Node(data=4)
root.left = Node(data=2)
root.left.left = Node(data=1)
root.left.right = Node(data=3)
root = self.binary_tree.delete(node=root, data=2)
assert root.left.data == 3
assert root.left.left.data == 1
def test_delete_node_remove_root_only_right_child(self):
bt = BinaryTree()
bt.root = Node(4)
bt.root.right_child = Node(6)
bt.count = 2
bt.delete_node(4)
self.assertEqual(6, bt.root.value)
self.assertEqual(None, bt.root.left_child)
self.assertEqual(None, bt.root.right_child)
self.assertEqual(1, bt.count)
def test_delete_node_remove_root_right_and_left_child(self):
bt = BinaryTree()
bt.root = Node(4)
bt.root.left_child = Node(2)
bt.root.right_child = Node(6)
bt.root.right_child.right_child = Node(8)
bt.count = 4
bt.delete_node(4)
self.assertEqual(6, bt.root.value)
self.assertEqual(2, bt.root.left_child.value)
self.assertEqual(8, bt.root.right_child.value)
self.assertEqual(None, bt.root.right_child.right_child)
self.assertEqual(3, bt.count)
def helper(start, end):
if start >= end:
return [None] if start > end else [Node(start)]
res = []
for i in range(start, end):
left = helper(start, i)
right = helper(i + 1, end)
for j in left:
for k in right:
node = Node(i)
node.left = j
node.right = k
res.append(node)
return res
def test_find_node(self):
bt = BinaryTree()
bt.root = Node(4)
bt.root.left_child = Node(2)
bt.root.right_child = Node(6)
bt.root.left_child.right_child = Node(3)
bt.root.right_child.left_child = Node(5)
bt.root.right_child.right_child = Node(8)
bt.root.right_child.right_child.left_child = Node(7)
bt.root.right_child.right_child.right_child = Node(12)
# test 1
found_node, previous_node = bt.find_node(bt.root, None, 4)
self.assertEqual(bt.root, found_node)
self.assertEqual(None, previous_node)
# test 2
found_node, previous_node = bt.find_node(bt.root, None, 2)
self.assertEqual(bt.root.left_child, found_node)
self.assertEqual(bt.root, previous_node)
# test 3
found_node, previous_node = bt.find_node(bt.root, None, 12)
self.assertEqual(bt.root.right_child.right_child.right_child,
found_node)
self.assertEqual(bt.root.right_child.right_child, previous_node)
# test 4:
found_node, previous_node = bt.find_node(bt.root, None, 999)
self.assertEqual(None, found_node)
self.assertEqual(None, previous_node)
def test_bt_lca(self):
BT = Node(50) # 50
BT.insert(25) # / \
BT.insert(75) # 25 75
BT.insert(60) # / \ / \
BT.insert(100) # 20 30 60 100
BT.insert(80) # /
BT.insert(20) # 80
BT.insert(30)
self.assertEqual(
lowest_common_ancestor_BT(BT, BT.left, BT.right).data, 50)
self.assertEqual(lowest_common_ancestor_BT(BT, BT, BT).data, 50)
self.assertEqual(lowest_common_ancestor_BT(BT, BT, BT.right).data, 50)
self.assertEqual(lowest_common_ancestor_BT(BT, BT.left, BT).data, 50)
self.assertEqual(
lowest_common_ancestor_BT(BT, BT.left.left, BT.left.right).data,
25)
self.assertEqual(
lowest_common_ancestor_BT(BT, BT.right.left, BT.right.right).data,
75)
self.assertEqual(
lowest_common_ancestor_BT(BT, BT.left.left, BT.right.right).data,
50)
self.assertEqual(
lowest_common_ancestor_BT(BT, BT.right.left,
BT.right.right.left).data, 75)
self.assertEqual(
lowest_common_ancestor_BT(BT, BT.left.right, BT.left.right).data,
30)
def tree_creator(arr, parent=None):
# if arr is empty
if len(arr) == 0:
return None
node = Node(arr[0])
node.parent = parent
# if there is only one node in the array
if len(arr) == 1:
return node
subArr = arr[1:]
left = []
right = []
for i in range(len(subArr)):
if subArr[i] < node.data:
left.append(subArr[i])
else:
right = subArr[i:]
break
node.left = tree_creator(left, node)
node.right = tree_creator(right, node)
return node
def generate_huffman_tree(array):
while len(array) > 1:
array.sort(key=lambda array: array[0])
first = array.pop(0)
second = array.pop(0)
node = Node(first[0] + second[0])
if type(first[1]) is str:
node.left = Node(first[1])
else:
node.left = first[1]
if type(second[1]) is str:
node.right = Node(second[1])
else:
node.right = second[1]
array.append((first[0] + second[0], node))
return array[0][1]
def list_to_binary(list):
if len(list) == 0:
return None
if len(list) == 1:
node = Node(list[0])
return node
else:
center_index = math.floor(len(list) / 2)
left_tree = list[:center_index]
right_tree = list[center_index + 1:]
node = Node(list[center_index])
if len(left_tree) > 0:
node.left = list_to_binary(left_tree)
if len(right_tree) > 0:
node.right = list_to_binary(right_tree)
return node
def prepost(pr, pr_s, pr_e, po, po_s, po_e, n):
"""
:type pr:list
:type pr_s:int
:type pr_e:int
:type po:list
:type po_s:int
:type po_e:int
:type n:dict
:param pr:
:param pr_s:
:param pr_e:
:param po:
:param po_s:
:param po_e:
:param n:
:return:
"""
if pr_s > pr_e or po_s > po_e:
return None
head = Node(pr[pr_s])
index = n.get(pr[pr_s + 1])
head.left = prepost(pr, pr_s + 1, pr_s + 1 + index - po_s, po, po_s,
index, n)
head.right = prepost(pr, pr_s + 2 + index - po_s, po, index + 1,
po_e - 1, n)
return head
def preinf(p, ps, pe, i, ii, ie, n):
"""
:type p:list
:type ps:int
:type pe:int
:type i:list
:type ii:int
:type ie:int
:type n:dict
:param p:
:param ps:
:param pe:
:param i:
:param ii:
:param ie:
:param n:
:return:
"""
if ps > pe:
return n
head = Node(p[ps])
index = n.get(p[ps])
head.left = preinf(p, ps + 1, ps + index - ii, i, ii, index - 1, node)
head.right = preinf(p, ps + index + 1 - ii, pe, i, index + 1, ie, node)
return head
def infpost(i, ii, ie, p, ps, pe, n):
"""
:type i:list
:type ii:int
:type ie:int
:type p:list
:type ps:int
:type pe:int
:type n:dict
:param i:
:param ii:
:param ie:
:param p:
:param ps:
:param pe:
:param n:
:return:
"""
if ii > ie or ps > pe:
return n
head = Node(p[pe])
index = n.get(p[pe])
head.left = infpost(i, ii, index - 1, p, ps, ps + index - 1 - ii, node)
head.right = infpost(i, index + 1, ie, p, ps + index - ii, pe - 1,
node)
return head
def gen_huffman_tree(arr):
"""生成霍夫曼树"""
li = list()
for v in arr:
node = Node(v)
li.append(node)
while len(li) > 1:
# 根据节点的权重值对节点进行排序
li.sort(key=lambda n: n.data)
# 取出前两个树构造新树
n1 = li.pop(0)
n2 = li.pop(0)
new_node = Node(n1.data + n2.data)
new_node.lchild = n1
new_node.rchild = n2
li.append(new_node)
return BinaryTree(li.pop(0))
def test_empy_binary_tree(self):
self.assertEqual(lowest_common_ancestor_BT(None, None, None), None)
BT = Node(None)
self.assertEqual(lowest_common_ancestor_BT(BT, BT, BT), None)
self.assertEqual(lowest_common_ancestor_BT(BT, None, None), None)
self.assertEqual(lowest_common_ancestor_BT(None, BT, None), None)
self.assertEqual(lowest_common_ancestor_BT(None, None, BT), None)
def test_tree_insert_root(self):
"""
This test makes sure that root is properly inserted.
"""
self.root = Node(random.randint(0, 100), random.randint(0, 100))
self.keys = [self.root.key]
self.assertEqual(self.inorder(self.root, []), sorted(self.keys))
def helper(l, lo, hi):
if lo > hi:
return
mid = (lo + hi) >> 1
node = Node(l[mid])
node.left_child = helper(l, lo, mid - 1)
node.right_child = helper(l, mid + 1, hi)
return node
def insert(self, new_val):
current = self.root
while current:
if new_val >= current.value:
if not current.right:
current.right = Node(new_val)
return
current = current.right
else:
if not current.left:
current.left = Node(new_val)
return
current = current.left
def _insert_value(self, node, data):
if node is None:
node = Node(data)
else:
if data <= node.data:
node.left = self._insert_value(node.left, data)
else:
node.right = self._insert_value(node.right, data)
return node
def recurse(i, j):
if j - i == 0:
return None
mid = j // 2 + i // 2
root = Node(val=vals[mid])
root.left = recurse(i, mid)
root.right = recurse(mid + 1, j)
return root
def parse_token(tokens):
"""
parse tokens from lexical_parse.py;
1. trait tokens in "()" as a expression token;
2. find the lowest operator;
3. binary split tokens with lowest operator;
4. process left tokens and right tokens
:param tokens: token list, the toke could be number, operator, scope and expression
:return: syntax binary tree
"""
token_size = len(tokens)
if token_size == 0:
raise SyntaxError("empty token")
elif token_size == 1:
token = tokens[0]
token_type = token.type
token_value = token.value
if token_type == TYPE_OPERATOR:
raise SyntaxError("expression should be number or sub expression, but %s is an operator" % token_value)
elif token_type == TYPE_SCOPE:
raise SyntaxError("expression should be number or sub expression, but %s is a parentheses" % token_value)
elif token_type == TYPE_NUM:
return Node(token)
else:
# expression need to binary split
tokens = token_value
# token is a expression, split it with operator
# split tokens with ()
token_without_parentheses = _split_sub_expression(tokens)
# find lowest operator
lowest_priority_operator_index = _find_lowest_priority_operator(token_without_parentheses)
if lowest_priority_operator_index == -1:
raise SyntaxError("can not find operator")
# split
left_sub_tokens = token_without_parentheses[:lowest_priority_operator_index]
right_sub_tokens = token_without_parentheses[lowest_priority_operator_index + 1:]
node = Node(token_without_parentheses[lowest_priority_operator_index])
node.left = parse_token(left_sub_tokens)
node.right = parse_token(right_sub_tokens)
return node
def generate_node(node_str):
"""
利用节点数据建立node
:type node_str:str
:param node_str:
:return:
"""
if node_str == "#":
return None
return Node(node_str)
def __init__(self, source_code):
# source code of the program
self.__source_code = source_code
# data structure for Identifiers table
self.__identifiers_table = Node()
# data structure for constants
self.__constants_table = Node()
# data structure for codification table
self.__cod_table = {}
# data structure for program internal form
self.__PIF = []
# name of output file for constants table
self.__constants_table_out = file_name.split(".")[0] + "_const.txt"
# name of output file for PIF
self.__PIF_out = file_name.split(".")[0] + "_pif.txt"
# name of output file for Symbol table
self.__identifiers_table_out = file_name.split(".")[0] + "_identifier.txt"
self.__populate_cod_table()
def _insert_value(self, node, data):
if node is None:
node = Node(data)
else:
# 주어진 이진 트리에 무작위로 배치하기 위한 알고리즘
random_case = randint(0, 10)
if random_case >= randint(0, self.random_level):
node.left = self._insert_value(node.left, data)
else:
node.right = self._insert_value(node.right, data)
return node
