def check_tree_by_array(output, tree_array):
tree = Tree()
tree.add(tree_array)
tree_str = tree.print_tree()
is_correct = check_separeted_text(output, tree_str)
assert is_correct, '\nОжидал дерево:\n{}\nПолучил:\n{}\n'.format(tree_str, output)
def check_node_elements(output, tree_array, value):
tree = Tree()
tree.add(tree_array)
node_str = tree.print_node(value)
is_correct = check_separeted_text(output, node_str)
assert is_correct, '\nОжидал: {}\nПолучил: {}\n'.format(node_str, output)
def setup(self):
self.test_tree = Tree()
self.test_key_4 = 4
self.test_key_2 = 2
self.test_key_5 = 5
self.test_key_3 = 3
self.test_key_6 = 6
self.test_key_1 = 1
self.test_data = 'test_data'
def bst_sequences_backtrack(nums: List[int]) -> List[List[int]]:
tree = Tree.create_bst(tree_vals)
root = tree.root
ret = []
level = 0
# use level to trace the depth for recusion for debugging
def backtrack(choices, weave, level=0):
if not choices:
ret.append(weave)
for i in range(len(choices)):
# pick node to put in weave
node = choices[i]
# new next choices = remaning next choices + the picked node's children
next_choices = choices[:i] + choices[i + 1:]
if node.left: next_choices.append(node.left)
if node.right: next_choices.append(node.right)
backtrack(next_choices, weave + [node.val], level + 1)
backtrack([root], [])
return ret
def build_database(structure, num_keys, key_value_pairs):
if structure == 'binary':
database = Tree()
for i in key_value_pairs:
database.insert(i)
return database
elif structure == 'AVL':
database = AVL()
for i in key_value_pairs:
database.insert(i)
return database
elif structure == 'hash':
database = LPHashTable(num_keys, h_rolling)
for i in key_value_pairs:
database.insert(i[0], i[1])
return database
def test_list_of_depths(self):
values, expect = test_case
tree = Tree.from_list_bfs(values)
root = tree.root
if not root:
return
self.assertEqual(list_of_depths(root), expect)
def test_find_rand_value(self):
bst = Tree()
for i in [[10, 1], [12, 2], [11, 3], [14, 4], [13, 5]]:
bst.insert(i)
for j in range(100):
search_for = random.randint(10, 14)
r = bst.search(search_for)
if search_for == 10:
s = [10, 1]
elif search_for == 11:
s = [11, 3]
elif search_for == 12:
s = [12, 2]
elif search_for == 13:
s = [13, 5]
elif search_for == 14:
s = [14, 4]
self.assertEqual(r, s)
def test_insert_rand_values(self):
for num in range(100):
bst = Tree()
L = []
M = []
for i in range(100):
rand_int = random.randint(1, 100)
if rand_int not in L:
L.append(rand_int)
for j in L:
rand_ints = []
rand_int_2 = random.randint(1, 100)
rand_ints.append(j)
rand_ints.append(rand_int_2)
M.append(rand_ints)
for k in M:
r = bst.insert(k)
self.assertEqual(r, True)
def setUp(self):
self._sub_tree = Node("A", Node("W", Node(1), Node(2)),
Node("X", Node(3), Node(4)))
self._tree = Tree(
"R",
self._sub_tree,
Node("B", Node("Y", Node(5), Node(6)), Node("Z", Node(7))),
)
def setup(self):
self.test_tree = Tree()
self.test_key_4 = 4
self.test_key_2 = 2
self.test_key_5 = 5
self.test_key_3 = 3
self.test_key_6 = 6
self.test_key_1 = 1
self.test_data = "test_data"
def test_lca(self):
tree = Tree.from_list_bfs(tree_vals)
root = tree.root
assert root != None and root.left and root.right
self.assertEqual(lca1(root, root.left, root.right), root)
self.assertEqual(lca2(root, root.left, root.right), root)
assert root != None and root.left.right and root.left.left
self.assertEqual(lca1(root, root.left.right, root.left.left),
root.left)
self.assertEqual(lca2(root, root.left.right, root.left.left),
root.left)
def answer_two(expression):
an = Answer()
stack = Stack()
result = Fraction(0, 1)
# testsuff = "1 1 chu 0 chu 1'1/5 chu 2 +".split(" ")
suffix = Tree.infix_to_suffix(expression.get_expression())
str = " ".join(suffix)
# print(str)
if not suffix:
return
is_num = None
for item in suffix:
try:
is_num = True
result = Answer.get_fraction(item)
except Exception:
is_num = False
if is_num:
stack.push(result)
else:
flag = {
'+': 1,
'-': 2,
'x': 3,
'÷': 4,
}.get(item, 5)
if flag == 1:
a = stack.pop()
b = stack.pop()
stack.push(a + b)
elif flag == 2:
a = stack.pop()
b = stack.pop()
stack.push(b - a)
elif flag == 3:
a = stack.pop()
b = stack.pop()
stack.push(a * b)
elif flag == 4:
a = stack.pop()
b = stack.pop()
if a == 0:
print("you 0")
an.wronum = 1
break
stack.push(b / a)
elif flag == 5:
pass
expression.set_fraction(stack.peek())
expression.set_value(stack.peek())
return an.wronum
def bst_sequences(nums: List[int]) -> List[List[int]]:
tree = Tree.create_bst(tree_vals)
root = tree.root
def fn(node) -> List[List[int]]:
if not node:
return [[]]
ret = []
left = fn(node.left)
right = fn(node.right)
for seq_left in left:
for seq_right in right:
weave(seq_left, seq_right, [node.val], ret)
return ret
return fn(root)
def test_inorder_successor(self):
tree = Tree.from_list_parent(tree_vals)
root = tree.root
# 20: if has right
node = root.right
self.assertEqual(inorder_successor_v2(node), 23)
# 8: if left node has no right, then it is parent
node = root.left.left
self.assertEqual(inorder_successor_v2(node), 9)
# 11: if right node has not right, then it is right parent of parent
node = root.left.right
self.assertEqual(inorder_successor_v2(node), 13)
# 13
node = root
self.assertEqual(inorder_successor_v2(node), 15)
def get_tree(formula_list):
if 'ev_' in formula_list:
if len(formula_list) != 3:
sys.exit("\033[1;31;47m SyntaxError: Improper use of ev_! \033[0m")
else:
left = None
right = get_tree(formula_list[2])
return Tree({'Value': 'ev', 'Bound': convert_bracket(formula_list[1][1:-1])},left,right)
elif 'alw_' in formula_list:
if len(formula_list) != 3:
sys.exit("\033[1;31;47m SyntaxError: Improper use of alw_! \033[0m")
else:
left = None
right = get_tree(formula_list[2])
return Tree({'Value': 'alw', 'Bound': convert_bracket(formula_list[1][1:-1])},left,right)
elif 'not_' in formula_list:
if len(formula_list) != 2:
sys.exit("\033[1;31;47m SyntaxError: Improper use of not_! \033[0m")
else:
left = None
right = get_tree(formula_list[1])
return Tree({'Value': 'not', 'Bound': None},left,right)
elif 'and_' in formula_list:
if len(formula_list) != 3:
sys.exit("\033[1;31;47m SyntaxError: Improper use of and_! \033[0m")
else:
left = get_tree(formula_list[0])
right = get_tree(formula_list[2])
return Tree({'Value': 'and', 'Bound': None},left,right)
elif 'or_' in formula_list:
if len(formula_list) != 3:
sys.exit("\033[1;31;47m SyntaxError: Improper use of or_! \033[0m")
else:
left = get_tree(formula_list[0])
right = get_tree(formula_list[2])
return Tree({'Value': 'or', 'Bound': None},left,right)
elif 'until_' in formula_list:
if len(formula_list) != 4:
sys.exit("\033[1;31;47m SyntaxError: Improper use of until_! \033[0m")
else:
left = get_tree(formula_list[0])
right = get_tree(formula_list[3])
return Tree({'Value': 'until', 'Bound': convert_bracket(formula_list[2][1:-1])},left,right)
else:
return Tree({'Value': convert_predict(formula_list), 'Bound': None}, None,None)
class TestTree:
def setup(self):
self.test_tree = Tree()
self.test_key_4 = 4
self.test_key_2 = 2
self.test_key_5 = 5
self.test_key_3 = 3
self.test_key_6 = 6
self.test_key_1 = 1
self.test_data = 'test_data'
def test_insert(self):
root = self.test_tree.insert(self.test_key_4, self.test_data)
assert root == 'Root node created'
node = self.test_tree.insert(self.test_key_2, self.test_data)
assert node == 'New node created'
duplicate_node = self.test_tree.insert(self.test_key_2, self.test_data)
assert duplicate_node == 'Node with this key already exists'
def test_find_empty_tree(self):
message = self.test_tree.find(1)
assert message == 'Empty Tree'
def test_find_does_not_exist(self):
self.test_tree.insert(self.test_key_4, self.test_data)
self.test_tree.insert(self.test_key_2, self.test_data)
self.test_tree.insert(self.test_key_5, self.test_data)
no_node = self.test_tree.find(self.test_key_3)
assert no_node == 'Node with this key does not exist'
def test_find(self):
self.test_tree.insert(self.test_key_4, self.test_data)
self.test_tree.insert(self.test_key_2, self.test_data)
self.test_tree.insert(self.test_key_5, self.test_data)
root_node = self.test_tree.find(self.test_key_4)
assert str(root_node) == 'Key: 4'
left_child = self.test_tree.find(self.test_key_2)
assert str(left_child) == 'Key: 2'
right_child = self.test_tree.find(self.test_key_5)
assert str(right_child) == 'Key: 5'
def test_create_key_list(self):
self.test_tree.insert(self.test_key_4, self.test_data)
self.test_tree.insert(self.test_key_2, self.test_data)
self.test_tree.insert(self.test_key_5, self.test_data)
self.test_tree.insert(self.test_key_3, self.test_data)
self.test_tree.insert(self.test_key_6, self.test_data)
self.test_tree.insert(self.test_key_1, self.test_data)
expected_result = [1, 2, 3, 4, 5, 6]
result = self.test_tree.create_key_list()
assert result == expected_result
from array_queue import Queue
from node import Node
from binary_tree import Tree
def bfs(tree):
queue = Queue()
visit_order = []
queue.enqueue(tree.get_root())
while not queue.is_empty():
node = queue.dequeue()
visit_order.append(node.value)
if node.has_left_child():
queue.enqueue(node.get_left_child())
if node.has_right_child():
queue.enqueue(node.get_right_child())
return visit_order
if __name__ == '__main__':
tree = Tree("apple")
tree.get_root().set_left_child(Node("banana"))
tree.get_root().set_right_child(Node("cherry"))
tree.get_root().get_left_child().set_left_child(Node("dates"))
print(bfs(tree))
def test_deletion(self):
sample = Tree(14)
sample.insert(2)
sample.insert(56)
self.assertNotEqual(sample.delete_node(sample, 56), 0)
在前序遍历中，根节点之后，移动左子树大小的位置，就可以找到右子树
'''
from binary_tree import Tree, TreeNode
def construct(qianxu, zhongxu):
if not qianxu or not zhongxu:
return
root = TreeNode(qianxu[0])
pos = zhongxu.index(qianxu[0])
root.left = construct(qianxu[1:pos + 1], zhongxu[0:pos])
root.right = construct(qianxu[pos + 1:], zhongxu[pos + 1:])
return root
if __name__ == '__main__':
qianxu = [
50, 38, 29, 20, 14, 7, 25, 32, 36, 48, 41, 49, 91, 67, 59, 52, 60, 64,
66, 85, 70, 87, 98, 94, 100, 99
]
zhongxu = [
7, 14, 20, 25, 29, 32, 36, 38, 41, 48, 49, 50, 52, 59, 60, 64, 66, 67,
70, 85, 87, 91, 94, 98, 99, 100
]
root = construct(qianxu, zhongxu)
t = Tree()
t.bianli_ceng(root)
# [50, 38, 91, 29, 48, 67, 98, 20, 32, 41, 49, 59, 85, 94, 100, 14, 25, 36, 52, 60, 70, 87, 99, 7, 64, 66]
class TestTree:
def setup(self):
self.test_tree = Tree()
self.test_key_4 = 4
self.test_key_2 = 2
self.test_key_5 = 5
self.test_key_3 = 3
self.test_key_6 = 6
self.test_key_1 = 1
self.test_data = "test_data"
def test_insert(self):
root = self.test_tree.insert(self.test_key_4, self.test_data)
assert root == "Root node created"
node = self.test_tree.insert(self.test_key_2, self.test_data)
assert node == "New node created"
duplicate_node = self.test_tree.insert(self.test_key_2, self.test_data)
assert duplicate_node == "Node with this key already exists"
def test_find_empty_tree(self):
message = self.test_tree.find(1)
assert message == "Empty Tree"
def test_find_does_not_exist(self):
self.test_tree.insert(self.test_key_4, self.test_data)
self.test_tree.insert(self.test_key_2, self.test_data)
self.test_tree.insert(self.test_key_5, self.test_data)
no_node = self.test_tree.find(self.test_key_3)
assert no_node == "Node with this key does not exist"
def test_find(self):
self.test_tree.insert(self.test_key_4, self.test_data)
self.test_tree.insert(self.test_key_2, self.test_data)
self.test_tree.insert(self.test_key_5, self.test_data)
root_node = self.test_tree.find(self.test_key_4)
assert str(root_node) == "Key: 4"
left_child = self.test_tree.find(self.test_key_2)
assert str(left_child) == "Key: 2"
right_child = self.test_tree.find(self.test_key_5)
assert str(right_child) == "Key: 5"
def test_create_key_list(self):
self.test_tree.insert(self.test_key_4, self.test_data)
self.test_tree.insert(self.test_key_2, self.test_data)
self.test_tree.insert(self.test_key_5, self.test_data)
self.test_tree.insert(self.test_key_3, self.test_data)
self.test_tree.insert(self.test_key_6, self.test_data)
self.test_tree.insert(self.test_key_1, self.test_data)
expected_result = [1, 2, 3, 4, 5, 6]
result = self.test_tree.create_key_list()
assert result == expected_result
from collections import deque
from binary_tree import Tree, Node
class BreathFirstTraversal(object):
@staticmethod
def traverse(tree):
queue = deque()
root = tree.get_root()
queue.append(root)
while len(queue) != 0:
node = queue.popleft()
print(node.get_value())
if node.has_left():
queue.append(node.get_left())
if node.has_right():
queue.append(node.get_right())
if __name__ == '__main__':
tree = Tree("apple")
tree.get_root().set_left(Node("banana"))
tree.get_root().set_right(Node("cherry"))
tree.get_root().get_left().set_left(Node("dates"))
tree.get_root().get_left().set_right(Node("mangoes"))
BreathFirstTraversal.traverse(tree)
ret = []
while not ns.is_empty():
n = ns.pop()
if n:
ret.append(n.val)
ns.push(n.right)
ns.push(n.left)
return ret
def dfs_recursive(root):
"""
深度遍历，递归实现
:param root:
:return:
"""
if not root:
return []
ret = [root.val]
ret.extend(dfs_recursive(root.left))
ret.extend(dfs_recursive(root.right))
return ret
if __name__ == '__main__':
t = Tree([1, 2, 3, 4, 5])
print(dfs(t.root))
print(dfs_recursive(t.root))
else:
return max(leftHeight, rightHeight) + 1
def is_balanced(root):
if root is None: return True
if getHeight(root) == -1:
return False
else:
return True
if __name__ == "__main__":
bst = Tree()
bst.insert(10)
assert is_balanced(bst.root)
bst.insert(8)
assert is_balanced(bst.root)
bst.insert(12)
assert is_balanced(bst.root)
bst.insert(5)
bst.insert(6)
assert not is_balanced(bst.root)
print("all good")
# Definition for a binary tree node.
# class TreeNode(object):
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
from binary_tree import Tree
class Solution(object):
def binaryTreePaths(self, root):
"""
:type root: TreeNode
:rtype: List[str]
"""
l = list()
if not (root.left or root.right):
return str(root.val)
if root.left:
l.extend([str(root.val) + '->' + i for i in self.binaryTreePaths(root.left)])
if root.right:
l.extend([str(root.val) + '->' + i for i in self.binaryTreePaths(root.right)])
return l
print(Solution().binaryTreePaths(Tree([1,2,3,4,5]).root))
def test_insertion(self):
sample = Tree(5)
test = Tree(14)
self.assertEqual(sample.insert(10),test.insert(10))
def test_raise_exception(self):
test = Tree(9)
test.insert(33)
test.insert(56)
self.assertRaises(TypeError, test, "hello")
def test_deletion2(self):
test = Tree(9)
test.insert(33)
test.insert(56)
self.assertTrue(test.delete_node(test, 9), 0)
def test_check_subtree(self):
for tc in test_cases:
t1, t2, expect = tc
tree1, tree2 = Tree.from_list(t1), Tree.from_list(t2)
self.assertEqual(check_subtree(tree1.root, tree2.root), expect)
from binary_tree import Tree
def BstInorderFindFirstKeyLargerThan(v, tree):
candidate = None
curr = tree.get()
while curr:
if curr.v > v:
candidate = curr.v
curr = curr.l
else:
curr = curr.r
return candidate
if __name__ == "__main__":
tree = Tree()
tree.add(19)
tree.add(7)
tree.add(43)
tree.add(3)
tree.add(11)
tree.add(23)
tree.add(47)
tree.add(2)
tree.add(5)
tree.add(17)
tree.add(37)
tree.add(53)
tree.add(13)
tree.add(29)
tree.add(41)
import sys
def is_bst(node, min_val=None, max_val=None):
if min_val is None:
min_val = -sys.maxint - 1
if max_val is None:
max_val = sys.maxint
if node is None:
return True
if node.value <= min_val or node.value > max_val:
return False
if (not is_bst(node.leftChild, min_val, node.value) or
not is_bst(node.rightChild, node.value, max_val)):
return False
return True
if __name__ == "__main__":
bst = Tree()
assert bst.insert(40)
assert bst.insert(25)
assert bst.insert(10)
assert bst.insert(32)
assert bst.insert(78)
assert(is_bst(bst.root))
def is_bst(node, min_val=None, max_val=None):
if min_val is None:
min_val = -sys.maxint - 1
if max_val is None:
max_val = sys.maxint
if node is None:
return True
if node.value <= min_val or node.value > max_val:
return False
if (not is_bst(node.leftChild, min_val, node.value)
or not is_bst(node.rightChild, node.value, max_val)):
return False
return True
if __name__ == "__main__":
bst = Tree()
assert bst.insert(40)
assert bst.insert(25)
assert bst.insert(10)
assert bst.insert(32)
assert bst.insert(78)
assert (is_bst(bst.root))
if rightHeight == -1:
return -1
if abs(leftHeight - rightHeight) > 1:
return -1
else:
return max(leftHeight, rightHeight) + 1
def is_balanced(root):
if root is None: return True
if getHeight(root) == -1:
return False
else:
return True
if __name__ == "__main__":
bst = Tree()
bst.insert(10)
assert is_balanced(bst.root)
bst.insert(8)
assert is_balanced(bst.root)
bst.insert(12)
assert is_balanced(bst.root)
bst.insert(5)
bst.insert(6)
assert not is_balanced(bst.root)
print("all good")
from binary_tree import Tree
class Solution:
def isSymmetric(self, root):
"""
:type root: TreeNode
:rtype: bool
"""
# def isSame(p, q):
# if p and q:
# return p.val == q.val and isSame(p.left, q.left) and isSame(p.right, q.right)
# return p == q
def isSym(p, q):
if p and q:
return p.val == q.val and isSym(p.left, q.right) and isSym(
p.right, q.left)
return p == q
return isSym(root.left, root.right) if root else True
s = Solution()
print(s.isSymmetric(Tree([1, 2, 2, 'null', 3, 'null', 3]).root))
right = check(root.right)
print(root.val, left, right)
# if left == -1 or right == -1 or abs(left - right) > 1:
# return -1
# print(1 + max(left, right))
return 1 + max(left, right)
if not root: return True
print(root.val, depth(root.right), depth(root.left))
return abs(depth(root.right) -
depth(root.left)) <= 1 and self.isBalanced(
root.right) and self.isBalanced(root.left)
def isBalanced2(self, root):
def check(root):
if root is None:
return 0
left = check(root.left)
right = check(root.right)
print(root.val, left, right)
if left == -1 or right == -1 or abs(left - right) > 1:
return -1
# print(1 + max(left, right))
return 1 + max(left, right)
return check(root) != -1
s = Solution()
print(s.isBalanced(Tree([1, 'null', 3, 2]).root))
