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))