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 test_1(self):
# Given
s_root = TreeNode(3)
s_left = TreeNode(4)
s_right = TreeNode(5)
s_left_left = TreeNode(1)
s_left_right = TreeNode(2)
s_root.left = s_left
s_root.right = s_right
s_root.left.left = s_left_left
s_root.left.right = s_left_right
t_root = TreeNode(4)
t_left = TreeNode(1)
t_right = TreeNode(2)
t_root.left = t_left
t_root.right = t_right
# When
output = self.sut.isSubtree(s_root, t_root)
# Then
self.assertEqual(True, output)
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_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_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_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():
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 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():
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 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)
def test1(self):
s = Solution()
node1 = TreeNode(1)
node2 = TreeNode(2)
node1.left = node2
root = s.recoverTree(node1)
self._inorder(root)
def invertTree(self, root: TreeNode) -> TreeNode:
if root is None:
return None
temp = root.right
root.right = self.invertTree(root.left)
root.left = self.invertTree(temp)
return root
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)
def mirrorTree(self, root: TreeNode) -> TreeNode:
# 为空返回
if not root: return
# 保存左节点，就像a，b互换值需要一个临时变量
temp = root.left
root.left = self.mirrorTree(root.right)
root.right = self.mirrorTree(temp)
return root
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 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 insertIntoBST(self, root: TreeNode, val: int) -> TreeNode:
if not root:
return TreeNode(val)
if root.val >= val:
root.left = self.insertIntoBST(root.left, val)
else:
root.right = self.insertIntoBST(root.right, val)
return root
def helper(root: TreeNode, val: int) -> TreeNode:
if not root:
return TreeNode(val)
if val > root.val:
root.right = helper(root.right, val)
else:
root.left = helper(root.left, val)
return root
def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode:
if not preorder:
return None
val = preorder[0]
k = inorder.index(val)
root = TreeNode(val)
root.left = self.buildTree(preorder[1:k + 1], inorder[:k])
root.right = self.buildTree(preorder[k + 1:], inorder[k + 1:])
return root
def helper(root: TreeNode) -> TreeNode:
if root:
helper(root.left)
helper(root.right)
if root:
if root.left and root.left.val == 0 and not root.left.left and not root.left.right:
root.left = None
if root.right and root.right.val == 0 and not root.right.right and not root.right.left:
root.right = None
def test():
root = TreeNode(5)
root.left = TreeNode(6)
root.right = TreeNode(1)
# pudb.set_trace()
res = max_avg(root)
assert res == 6
def test(self):
solution = Solution()
tree_node = TreeNode(4)
tree_node.left = TreeNode(2)
tree_node.left.left = TreeNode(3)
tree_node.left.right = TreeNode(1)
result = solution.addOneRow(tree_node, 1, 3)
print("RESULT!", result)
def removeLeafNodes(self, root: TreeNode, target: int) -> TreeNode:
if not root:
return None
root.left = self.removeLeafNodes(root.left, target)
root.right = self.removeLeafNodes(root.right, target)
if not root.left and not root.right and root.val == target:
return None
else:
return root
def tree():
root = TreeNode(1)
root.left = TreeNode(2)
root.right = TreeNode(3)
root.left.left = TreeNode(4)
root.right.left = TreeNode(2)
root.right.left.left = TreeNode(4)
root.right.right = TreeNode(4)
return root
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 helper(nums: List[int], start: int, end: int):
if start <= end:
value = max(nums[start:end + 1])
index = nums.index(value)
node = TreeNode(value)
node.left = helper(nums, start, index - 1)
node.right = helper(nums, index + 1, end)
return node
else:
return None
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 tree1():
root = TreeNode(4)
root.left = TreeNode(2)
root.right = TreeNode(6)
root.left.left = TreeNode(1)
root.left.right = TreeNode(3)
root.right.left = TreeNode(5)
root.right.right = TreeNode(7)
return root
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 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)
def flatten(self, root: TreeNode) -> None:
"""
Do not return anything, modify root in-place instead.
"""
if not root:
return None
self.flatten(root.right)
self.flatten(root.left)
root.right = self.pre
root.left = None
self.pre = root
def test2(self):
root = TreeNode('a')
root.left = TreeNode('b')
root.right = TreeNode('c')
root.left.left = TreeNode('d')
Solution().invert(root)
result = []
self.preorder_list(root, result)
self.assertEqual(result, ['a', 'c', 'b', 'd'])
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 helper(preorder: List[int], inorder: List[int], preleft: int,
preright: int, inleft: int, inright: int):
if inleft > inright:
return None
val = preorder[preleft]
mid = inorder.index(val)
root = TreeNode(val)
root.left = helper(preorder, inorder, preleft + 1,
mid - inleft + preleft, inleft, mid - 1)
root.right = helper(preorder, inorder, mid - inleft + preleft + 1,
preright, mid + 1, inright)
return root
def test1(self):
root = TreeNode(8)
root.left = TreeNode(4)
root.right = TreeNode(12)
root.left.left = TreeNode(2)
root.left.right = TreeNode(6)
root.right.left = TreeNode(10)
root.right.right = TreeNode(14)
self.assertEqual(Solution().findCeilingFloor(root, 5), [4, 6])
def buildTree(self, inorder: List[int], postorder: List[int]) -> TreeNode:
if not postorder:
return None
# 从后续遍历中获取根节点
v = postorder[-1]
# 从中序遍历中获取左右子树的分割点
n = inorder.index(v)
# 创建根节点
root = TreeNode(v)
# 根据n来构建二叉树进行分割递归
root.left = self.buildTree(inorder[:n], postorder[:n])
root.right = self.buildTree(inorder[n + 1:], postorder[n:-1])
return root
def insertNode(root: TreeNode, num: int):
if num > root.value:
if root.right is None:
root.right = TreeNode(num)
return
else:
insertNode(root.right, num)
if num < root.value:
if root.left is None:
root.left = TreeNode(num)
return
else:
insertNode(root.left, num)
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
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)
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)
from solution import TreeNode, Solution
s = Solution()
# first test
root = TreeNode(3)
left, right = TreeNode(5), TreeNode(1)
left.left, left.right = TreeNode(6), TreeNode(2)
left.right.left, left.right.right = TreeNode(7), TreeNode(4)
right.left, right.right = TreeNode(0), TreeNode(8)
root.left, root.right = left, right
assert s.lowestCommonAncestor(root, root.left, root.right) == root
assert s.lowestCommonAncestor(root, root.right, root.left) == root
assert s.lowestCommonAncestor(root, root.left, root) == root
assert s.lowestCommonAncestor(root, root, root.right) == root
assert s.lowestCommonAncestor(root, root.left,
root.left.right.right) == root.left
assert s.lowestCommonAncestor(root, root.left.right.left,
root.left.left) == root.left
# second test
root = TreeNode(1)
left, right = TreeNode(2), TreeNode(3)
left.right = TreeNode(4)
root.left, root.right = left, right
def traverse(node, nodes):
nodes.append(node.val)
if node.left:
traverse(node.left, nodes)
if node.right:
traverse(node.right, nodes)
return nodes
s = Solution()
# test 1
root = TreeNode(5)
root.left = TreeNode(2)
root.right = TreeNode(13)
res = s.convertBST(root)
assert traverse(res, []) == [18, 20, 13]
# test 2
assert s.convertBST(None) is None
# test 3
root = TreeNode(2)
left = TreeNode(0)
left.left, left.right = TreeNode(-4), TreeNode(1)
root.left, root.right = left, TreeNode(3)
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
answ_root = TreeNode(1)
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)
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
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 # test 2
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
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("=====================")
from solution import TreeNode, Solution s = Solution() # first test root = TreeNode(1) root.left = TreeNode(2) root.right = TreeNode(3) root.left.left = TreeNode(4) assert s.tree2str(root) == '1(2(4))(3)' # second test root = TreeNode(1) root.left = TreeNode(2) root.right = TreeNode(3) root.left.right = TreeNode(4) assert s.tree2str(root) == '1(2()(4))(3)' # third test assert s.tree2str(None) == '' # fourth test root = TreeNode(1) root.right = TreeNode(3)
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)
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
