def test1(self): s = Solution() node1 = TreeNode(1) node2 = TreeNode(2) node1.left = node2 root = s.recoverTree(node1) self._inorder(root)
def test_1(): sol = Solution() a2 = TreeNode(2) a1 = TreeNode(1) a4 = TreeNode(4) a2.left, a2.right = a1, a4 a3 = TreeNode(3) a5 = TreeNode(5) a4.left, a4.right = a3, a5 assert sol.isValidBST(a2)
def test_2(): sol = Solution() a2 = TreeNode(2) a6 = TreeNode(6) a4 = TreeNode(4) a2.left, a2.right = a6, a4 a3 = TreeNode(3) a5 = TreeNode(5) a4.left, a4.right = a3, a5 assert not sol.isValidBST(a2)
def test_1(): sol = Solution() a3 = TreeNode(3) a9 = TreeNode(9) a20 = TreeNode(20) a3.left, a3.right = a9, a20 a15 = TreeNode(15) a7 = TreeNode(7) a20.left, a20.right = a15, a7 assert sol.zigzagLevelOrder(a3) == [[3], [20, 9], [15, 7]]
def test_2(): sol = Solution() a1 = TreeNode(1) a0 = TreeNode(0) a1.right = a0 sol.recoverTree(a1) t0 = TreeNode(0) t1 = TreeNode(1) t0.right = t1 assert tree_eq(a1, t0)
def test_1(): sol = Solution() a1 = TreeNode(1) a0 = TreeNode(0) a3 = TreeNode(3) a1.left, a1.right = a0, a3 a2 = TreeNode(2) a4 = TreeNode(4) a3.left, a3.right = a2, a4 assert sol.maxDepth(a1) == 3 assert sol.maxDepth(a0) == 1 assert sol.maxDepth(a3) == 2
def test_1(): t4 = TreeNode(4) t2 = TreeNode(2) t6 = TreeNode(6) t4.left = t2 t4.right = t6 t3 = TreeNode(3) t2.right = t3 t5 = TreeNode(5) t7 = TreeNode(7) t6.left = t5 t6.right = t7 it = BSTIterator(t4) assert it.hasNext() assert it.next() == 2 assert it.hasNext() assert it.next() == 3 assert it.hasNext() assert it.next() == 4 assert it.hasNext() assert it.next() == 5 assert it.hasNext() assert it.next() == 6 assert it.hasNext() assert it.next() == 7 assert not it.hasNext()
def test1(self): s = Solution() node1 = TreeNode(1) node2 = TreeNode(2) node3 = TreeNode(3) node4 = TreeNode(4) node5 = TreeNode(5) node6 = TreeNode(6) node7 = TreeNode(7) node4.left = node2 node4.right = node6 node2.left = node1 node2.right = node3 node6.left = node5 node6.right = node7 res = s.get_next_node(node4, node1) print res.val
def test_3(): sol = Solution() a1 = TreeNode(1) a3 = TreeNode(3) a1.right = a3 a2 = TreeNode(2) a3.right = a2 sol.recoverTree(a1) t1 = TreeNode(1) t2 = TreeNode(2) t1.right = t2 t3 = TreeNode(3) t2.right = t3 assert tree_eq(a1, t1)
def test_2(): sol = Solution() a = TreeNode(1) b1 = TreeNode(1) b2 = TreeNode(1) a.left, a.right = b1, b2 c2 = TreeNode(1) b1.right = c2 c4 = TreeNode(1) b2.right = c4
def test1(self): node1 = TreeNode(1) node2 = TreeNode(2) node3 = TreeNode(3) node4 = TreeNode(4) node5 = TreeNode(5) node6 = TreeNode(6) node7 = TreeNode(7) node1.left = node2 node1.right = node3 node2.left = node4 node2.right = node5 node3.left = node6 node3.right = node7 target = 7 s = PathSum() res = s.get_all_paths(node1, target) # return res + '**' print res
def test_1(): t1 = TreeNode(1) t2 = TreeNode(2) t3 = TreeNode(3) t1.left = t2 t1.right = t3 t4 = TreeNode(4) t5 = TreeNode(5) t3.left = t4 t3.right = t5 _test_codec(t1)
def test_2(): a1 = TreeNode(1) a0 = TreeNode(0) a3 = TreeNode(3) a1.left, a1.right = a0, a3 a2 = TreeNode(2) a4 = TreeNode(4) a3.left, a3.right = a2, a4 b1 = TreeNode(1) b0 = TreeNode(0) b3 = TreeNode(3) b1.left, b1.right = b0, b3 b2 = TreeNode(2) b4 = TreeNode(6) b3.left, b3.right = b2, b4 sol = Solution() assert not sol.isSameTree(a1, b1)
def test_1(): sol = Solution() r = TreeNode(0) a1 = TreeNode(1) a2 = TreeNode(2) a3 = TreeNode(3) a4 = TreeNode(4) a5 = TreeNode(5) a6 = TreeNode(6) r.left, r.right = a1, a2 a2.left, a2.right = a3, a6 a3.left, a3.right = a4, a5 assert sol.inorderTraversal(r) == [1, 0, 4, 3, 5, 2, 6]
def test3(self): s = Solution() node1 = TreeNode(1) node2 = TreeNode(2) node3 = TreeNode(3) node4 = TreeNode(4) node5 = TreeNode(5) node6 = TreeNode(6) node7 = TreeNode(7) node4.left = node2 node4.right = node6 node2.left = node1 # node2.right = node3 node6.left = node5 node6.right = node7 res = s.get_next_node(node4, node2) print res res = s.get_next_node(node4, node1) self.assertEqual(node2, res) print res
def test_1(): sol = Solution() a = TreeNode(1) b1 = TreeNode(2) b2 = TreeNode(2) a.left, a.right = b1, b2 c1 = TreeNode(3) c2 = TreeNode(4) b1.left, b1.right = c1, c2 c3 = TreeNode(4) c4 = TreeNode(3) b2.left, b2.right = c3, c4 assert sol.isSymmetric(a)
def test_1(): n1 = TreeNode(1) n2 = TreeNode(2) n3 = TreeNode(3) n1.left = n2 n1.right = n3 n4 = TreeNode(4) n5 = TreeNode(5) n3.left = n4 n3.right = n5 assert sol.lowestCommonAncestor(n1, n4, n5) is n3 assert sol.lowestCommonAncestor(n1, n2, n4) is n1 assert sol.lowestCommonAncestor(n1, n2, n5) is n1
def test1(self): node1 = TreeNode(1) node2 = TreeNode(2) node3 = TreeNode(3) node4 = TreeNode(4) node5 = TreeNode(5) node6 = TreeNode(6) node7 = TreeNode(7) root = node4 root.left = node2 root.right = node6 node2.left = node1 node2.right = node3 node6.left = node5 node6.right = node7 s = Solution() res = s.find_kth(root, 2) self.assertEqual(node2, res) res = s.find_kth(root, 3) self.assertEqual(node3, res) res = s.find_kth(root, 1) self.assertEqual(node1, res)
def test_2(): t1 = TreeNode(1) t2 = TreeNode(2) t3 = TreeNode(3) t1.left = t2 t1.right = t3 t4 = TreeNode(4) t2.left = t4 t5 = TreeNode(5) t3.right = t5 t6 = TreeNode(6) t4.right = t6 t7 = TreeNode(7) t5.left = t7 _test_codec(t1)
from solution import Tree, TreeNode, MinHeap, convert_to_minHeap n1 = TreeNode(1) n2 = TreeNode(2) n3 = TreeNode(3, n1, n2) n4 = TreeNode(4) n5 = TreeNode(5) n6 = TreeNode(6, n4, n5) n7 = TreeNode(7, n3, n6) tree1 = Tree(n7) m1 = TreeNode(1) m3 = TreeNode(3, n1, None) tree2 = Tree(m3) tree3 = Tree() def test_solution(): assert convert_to_minHeap(tree1)._heap == [1, 2, 3, 7, 6, 4, 5] assert convert_to_minHeap(tree2)._heap == [1, 3] assert convert_to_minHeap(tree3)._heap == []
def constructOne(s): if s == '#': return None else: return TreeNode(int(s))
from solution import TreeNode, Solution s = Solution() # first test root = TreeNode(1) left, right = TreeNode(1), TreeNode(1) left.left, left.right = TreeNode(1), TreeNode(1) right.right = TreeNode(1) root.left, root.right = left, right assert s.isUnivalTree(root) # second test assert s.isUnivalTree(None) # third test root = TreeNode(2) left, right = TreeNode(2), TreeNode(2) left.left, left.right = TreeNode(5), TreeNode(2) root.left, root.right = left, right assert not s.isUnivalTree(root)
def createNode(s): s = s.strip() if s == '#': return None else: return TreeNode(int(s))
from solution import TreeNode, Solution s = Solution() root = TreeNode(6) root.left = TreeNode(2) root.right = TreeNode(8) root.left.right = TreeNode(4) assert s.lowestCommonAncestor(root, root.left, root.right) == root assert s.lowestCommonAncestor(root, root.left, root.left.right) == root.left assert s.lowestCommonAncestor(root, root.right, root) == root
def test_1(): """ 0, 1, 2, 3, 4, 5 """ sol = Solution() a1 = TreeNode(1) a5 = TreeNode(5) a3 = TreeNode(3) a1.left, a1.right = a5, a3 a2 = TreeNode(2) a4 = TreeNode(4) a3.left, a3.right = a2, a4 a0 = TreeNode(0) a4.right = a0 sol.recoverTree(a1) t1 = TreeNode(1) t0 = TreeNode(0) t3 = TreeNode(3) t1.left, t1.right = t0, t3 t2 = TreeNode(2) t4 = TreeNode(4) t3.left, t3.right = t2, t4 t5 = TreeNode(5) t4.right = t5 assert tree_eq(a1, t1)
from solution import TreeNode, Solution s = Solution() root = TreeNode(1) left, right = TreeNode(2), TreeNode(5) left.left, left.right, right.right = TreeNode(3), TreeNode(4), TreeNode(6) root.left, root.right = left, right s.flatten(root) ar = [1, 2, 3, 4, 5, 6] for el in ar: assert root.val == el if root and root.right: root = root.right
from solution import Solution, TreeNode s = Solution() # basic tests # [3, 9, 20, null, null, 15, 7] root = TreeNode(3) root.left = TreeNode(9) right = TreeNode(20) right.left, right.right = TreeNode(15), TreeNode(7) root.right = right answer = [[3], [20, 9], [15, 7]] actual = s.zigzagLevelOrder(root) assert actual == answer # empty tree assert s.zigzagLevelOrder(None) == [] # empty in between # [1, 2, 3, 4, null, null, 5] root = TreeNode(1) left = TreeNode(2) right = TreeNode(3) left.left, right.right = TreeNode(4), TreeNode(5) root.left, root.right = left, right answer = [[1], [3, 2], [4, 5]] assert s.zigzagLevelOrder(root) == answer
def constructOne(s): s = s.strip() if s == '#': return None else: return TreeNode(int(s))
def setUp(self): root = TreeNode(3) left = TreeNode(4) right = TreeNode(5) left_left = TreeNode(1) left_right = TreeNode(2) root.left = left root.right = right root.left.left = left_left root.left.right = left_right t_root = TreeNode(4) t_left = TreeNode(1) t_right = TreeNode(2) t_root.left = t_left t_root.right = t_right self.sut = EarliestAncestor(root)
from solution import TreeNode, Solution def rec_preorder(node, ar): ar.append(node.val) if node.left: rec_preorder(node.left, ar) if node.right: rec_preorder(node.right, ar) s = Solution() # test 1 root = TreeNode(1) root.right = TreeNode(2) root.right.left = TreeNode(3) nodes = [] rec_preorder(root, nodes) assert s.preorderTraversal(root) == nodes # test 2 root = TreeNode(1) left, right = TreeNode(2), TreeNode(3) left.left, left.right = TreeNode(4), TreeNode(5) right.left, right.right = TreeNode(6), TreeNode(7) root.left, root.right = left, right
def test_2(): n3 = TreeNode(3) n5 = TreeNode(5) n1 = TreeNode(1) n3.left = n5 n3.right = n1 n6 = TreeNode(6) n2 = TreeNode(2) n5.left = n6 n5.right = n2 n7 = TreeNode(7) n4 = TreeNode(4) n2.left = n7 n2.right = n4 n0 = TreeNode(0) n8 = TreeNode(8) n1.left = n0 n1.right = n8 assert sol.lowestCommonAncestor(n3, n5, n1) is n3 assert sol.lowestCommonAncestor(n3, n5, n4) is n5 assert sol.lowestCommonAncestor(n3, n5, n7) is n5 assert sol.lowestCommonAncestor(n3, n5, n6) is n5 assert sol.lowestCommonAncestor(n3, n5, n5) is n5
ar.append(node.val) if node.left: traverse(node.left, ar) else: ar.append(None) if node.right: traverse(node.right, ar) else: ar.append(None) return ar s = Solution() # first test root = TreeNode(1) right = TreeNode(0) right.left, right.right = TreeNode(0), TreeNode(1) root.right = right answ_root = TreeNode(1) answ_root.right, answ_root.right.right = TreeNode(0), TreeNode(1) assert traverse(s.pruneTree(root), []) == traverse(answ_root, []) # second test root = TreeNode(1) left, right = TreeNode(0), TreeNode(1) left.left, left.right = TreeNode(0), TreeNode(0) right.left, right.right = TreeNode(0), TreeNode(1) root.left, root.right = left, right
from solution import TreeNode, Solution node = TreeNode(5) node.left = TreeNode(3) node.left.left = TreeNode(2) node.left.left.left = TreeNode(1) node.left.right = TreeNode(4) node.right = TreeNode(7) node.right.left = TreeNode(6) node.right.right = TreeNode(8) def printNode(root): if root is None: return printNode(root.left) print(root.val) printNode(root.right) print("=====================") printNode(node) print("=====================") sol = Solution() node = sol.deleteNode(node, 5) print("=====================") printNode(node) print("=====================")
def test1(self): node1 = TreeNode(1) node3 = TreeNode(3) node5 = TreeNode(5) node4 = TreeNode(4) node2 = TreeNode(2) node7 = TreeNode(7) node8 = TreeNode(8) node9 = TreeNode(9) node1.left = node3 node1.right = node5 node3.left = node2 node3.right = node4 node2.left = node9 node4.right = node8 node5.right = node7 print_by_level(node1)
from solution import Solution from solution import TreeNode t1 = TreeNode(1) t2 = TreeNode(None) t3 = TreeNode(2) t4 = TreeNode(3) root = t1 #t1.left = t2 t1.right = t3 t3.left = t4 s = Solution() print(s.inorderTraversal(root))
def test_1(): sol = Solution() tgt = [] """ 1 \ 3 / 2 """ a = TreeNode(1) c = TreeNode(3) a.right = c b = TreeNode(2) c.left = b tgt.append(a) """ 3 / 2 / 1 """ c = TreeNode(3) b = TreeNode(2) c.left = b a = TreeNode(1) b.left = a tgt.append(c) """ 3 / 1 \ 2 """ c = TreeNode(3) a = TreeNode(1) c.left = a b = TreeNode(2) a.right = b tgt.append(c) """ 2 / \ 1 3 """ b = TreeNode(2) a = TreeNode(1) c = TreeNode(3) b.left = a b.right = c tgt.append(b) """ 1 \ 2 \ 3 """ a = TreeNode(1) b = TreeNode(2) a.right = b c = TreeNode(3) b.right = c tgt.append(a) ans = sol.generateTrees(3) assert forest_equal(ans, tgt)
from solution import TreeNode, Solution s = Solution() root = TreeNode(4) left, right = TreeNode(2), TreeNode(7) left.left, left.right = TreeNode(1), TreeNode(3) right.left, right.right = TreeNode(6), TreeNode(9) root.left, root.right = left, right inverted_root = s.invertTree(root) # im too lazy assert inverted_root.val == 4 assert (inverted_root.left.val, inverted_root.right.val) == (7, 2) assert (inverted_root.left.left.val, inverted_root.left.right.val) == (9, 6) assert (inverted_root.right.left.val, inverted_root.right.right.val) == (3, 1)
def traverse(node, nodes): nodes.append(node.val if node else None) if node: traverse(node.left, nodes) traverse(node.right, nodes) codec = Codec() # test 1 root = TreeNode(1) root.left = TreeNode(2) right = TreeNode(3) right.left, right.right = TreeNode(4), TreeNode(5) root.right = right deserialized = codec.deserialize(codec.serialize(root)) original_nodes = [] deser_nodes = [] traverse(root, original_nodes) traverse(deserialized, deser_nodes) assert original_nodes == deser_nodes
def setUp(self): root = TreeNode(1) node1 = TreeNode(2) node2 = TreeNode(2) root.left = node1 root.right = node2 node3 = TreeNode(3) node4 = TreeNode(3) node5 = TreeNode(3) node6 = TreeNode(3) node1.left = node3 node1.right = node4 node2.left = node5 node2.right = node6 node7 = TreeNode(4) node8 = TreeNode(4) node9 = TreeNode(4) node10 = TreeNode(4) node11 = TreeNode(4) node12 = TreeNode(4) node3.left = node7 node3.right = node8 node4.left = node9 node4.right = node10 node5.left = node11 node5.right = node12 node13 = TreeNode(5) node14 = TreeNode(5) node6.left = node13 node6.right = node14
def test_solution(): from solution import Tree, TreeNode, is_complete n1 = TreeNode(1) n2 = TreeNode(2) n3 = TreeNode(3, n1, n2) n4 = TreeNode(4) n5 = TreeNode(5) n6 = TreeNode(6, n4, n5) n7 = TreeNode(7, n3, n6) tree1 = Tree(n7) m1 = TreeNode(1) m3 = TreeNode(3, m1, None) tree2 = Tree(m3) p1 = TreeNode(1) p3 = TreeNode(3, None, p1) tree4 = Tree(p3) tree3 = Tree() assert is_complete(tree1) == True assert is_complete(tree2) == True assert is_complete(tree3) == True assert is_complete(tree4) == False