def test_solution(self):
self.assertEqual([[9], [3, 15], [20], [7]],
Solution().verticalOrder(
common.create_binary_tree(
[3, 9, 20, None, None, 15, 7])))
self.assertEqual([[4], [9], [3, 0, 1], [8], [7]],
Solution().verticalOrder(
common.create_binary_tree([3, 9, 8, 4, 0, 1, 7])))
def test_solution(self):
self.assertEqual(
1,
Solution().kthSmallest(
common.create_binary_tree([3, 1, 4, None, 2]), 1))
self.assertEqual(
3,
Solution().kthSmallest(
common.create_binary_tree([5, 3, 6, 2, 4, None, None, 1]), 3))
def test_solution(self):
self.assertEqual(
4,
Solution().countUnivalSubtrees(
common.create_binary_tree([5, 1, 5, 5, 5, None, 5])))
self.assertEqual(
3,
Solution().countUnivalSubtrees(
common.create_binary_tree([1, 3, 2, 4, 5, None, 6])))
def test_solution(self):
self.assertEqual(
7,
Solution().rob(
common.create_binary_tree([3, 2, 3, None, 3, None, 1])))
self.assertEqual(
9,
Solution().rob(common.create_binary_tree([3, 4, 5, 1, 3, None,
1])))
def test_solution(self):
self.assertEqual(
True,
Solution().isSymmetric(
common.create_binary_tree([1, 2, 2, 3, 4, 4, 3])))
self.assertEqual(
False,
Solution().isSymmetric(
common.create_binary_tree([1, 2, 2, None, 3, None, 3])))
def test_solution(self):
self.assertEqual([4, 5, 2, None, None, 3, 1],
common.convert_binary_tree_to_list(
Solution().upsideDownBinaryTree(
common.create_binary_tree([1, 2, 3, 4, 5]))))
self.assertEqual([4, None, 2, 3, 1],
common.convert_binary_tree_to_list(
Solution().upsideDownBinaryTree(
common.create_binary_tree([1, 2, 3, 4]))))
def test_solution(self):
self.assertEqual(
3,
Solution().longestConsecutive(
common.create_binary_tree(
[1, None, 3, 2, 4, None, None, None, 5])))
self.assertEqual(
2,
Solution().longestConsecutive(
common.create_binary_tree([2, None, 3, 2, None, 1])))
def test_solution(self):
root = common.create_binary_tree([1, None, 2])
p = common.get_tree_node(root, 0)
s = common.get_tree_node(root, 2)
self.assertEqual(s, Solution().inorderSuccessor(root, p))
root = common.create_binary_tree([2, 1, 3])
p = common.get_tree_node(root, 1)
s = common.get_tree_node(root, 0)
self.assertEqual(s, Solution().inorderSuccessor(root, p))
def test_solution(self):
self.assertEqual(
True,
Solution().hasPathSum(
common.create_binary_tree(
[5, 4, 8, 11, None, 13, 4, 7, 2, None, None, None, 1]),
22))
self.assertEqual(
False,
Solution().hasPathSum(common.create_binary_tree([]), 0))
def test_solution(self):
self.assertEqual(
5,
Solution().closestValue(
common.create_binary_tree([5, 4, 9, 2, None, 8, 10]),
6.124780))
self.assertEqual(
4,
Solution().closestValue(common.create_binary_tree([3, 2, 4, 1]),
4.142857))
def test_solution(self):
self.assertEqual(
True,
Solution().isValidBST(common.create_binary_tree([2, 1, 3])))
self.assertEqual(
False,
Solution().isValidBST(
common.create_binary_tree([5, 1, 4, None, None, 3, 6])))
self.assertEqual(
False,
Solution().isValidBST(common.create_binary_tree([1, 1])))
def test_solution(self):
tree = common.create_binary_tree([1, 3, None, None, 2])
Solution().recoverTree(tree)
self.assertEqual(
[3, 1, None, None, 2],
common.convert_binary_tree_to_list(tree))
tree = common.create_binary_tree([3, 1, 4, None, None, 2])
Solution().recoverTree(tree)
self.assertEqual(
[2, 1, 4, None, None, 3],
common.convert_binary_tree_to_list(tree))
def test_solution(self):
self.assertEqual([1],
Solution().closestKValues(
common.create_binary_tree([1]), 0.0, 1))
self.assertEqual(
sorted([1, 2]),
sorted(Solution().closestKValues(
common.create_binary_tree([3, 1, 4, 0, 2]), 1.5, 2)))
self.assertEqual(
sorted([1, 2, 3]),
sorted(Solution().closestKValues(
common.create_binary_tree([3, 2, 5, 1]), 1.0, 3)))
def test_solution(self):
self.assertEqual(
True,
Solution().isBalanced(
common.create_binary_tree([3, 9, 20, None, None, 15, 7])))
self.assertEqual(
False,
Solution().isBalanced(
common.create_binary_tree([1, 2, 2, 3, 3, None, None, 4, 4])))
self.assertEqual(
True,
Solution().isBalanced(
common.create_binary_tree(
[1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, None, None, 5,
5])))
def test_solution(self):
self.assertEqual(
25,
Solution().sumNumbers(
common.create_binary_tree([1, 2, 3])
))
self.assertEqual(
1026,
Solution().sumNumbers(
common.create_binary_tree([4, 9, 0, 5, 1])
))
self.assertEqual(
0,
Solution().sumNumbers(
common.create_binary_tree([])
))
def test_solution(self):
self.assertEqual(
[
[5, 4, 11, 2],
[5, 8, 4, 5]
],
Solution().pathSum(
common.create_binary_tree([5, 4, 8, 11, None, 13, 4, 7, 2, None, None, 5, 1]),
22
))
def test_solution(self):
tree = common.create_binary_tree(
[6, 2, 8, 0, 4, 7, 9, None, None, 3, 5])
p = common.get_tree_node(tree, 1)
q = common.get_tree_node(tree, 2)
self.assertEqual(tree, Solution().lowestCommonAncestor(tree, p, q))
p = common.get_tree_node(tree, 1)
q = common.get_tree_node(tree, 4)
self.assertEqual(common.get_tree_node(tree, 1),
Solution().lowestCommonAncestor(tree, p, q))
def test_solution(self):
self.assertEqual(
6,
Solution().maxPathSum(common.create_binary_tree([1, 2, 3])))
self.assertEqual(
42,
Solution().maxPathSum(
common.create_binary_tree([-10, 9, 20, None, None, 15, 7])))
self.assertEqual(
2,
Solution().maxPathSum(common.create_binary_tree([2, -1])))
self.assertEqual(
16,
Solution().maxPathSum(
common.create_binary_tree([
9, 6, -3, None, None, -6, 2, None, None, 2, None, -6, -6,
-6
])))
self.assertEqual(
-3,
Solution().maxPathSum(common.create_binary_tree([-3])))
def test_solution(self):
root = common.create_binary_tree([7, 3, 15, None, None, 9, 20])
iterator = BSTIterator(root)
self.assertEqual(3, iterator.next())
self.assertEqual(7, iterator.next())
self.assertTrue(iterator.hasNext())
self.assertEqual(9, iterator.next())
self.assertTrue(iterator.hasNext())
self.assertEqual(15, iterator.next())
self.assertTrue(iterator.hasNext())
self.assertEqual(20, iterator.next())
self.assertFalse(iterator.hasNext())
def test_solution(self):
tree = common.create_binary_tree([3, 5, 1, 6, 2, 0, 8, None, None, 7, 4])
p = common.get_tree_node(tree, 1)
q = common.get_tree_node(tree, 2)
self.assertEqual(tree, Solution().lowestCommonAncestor(tree, p, q))
p = common.get_tree_node(tree, 1)
q = common.get_tree_node(tree, 10)
self.assertEqual(p, Solution().lowestCommonAncestor(tree, p, q))
p = common.get_tree_node(tree, 9)
q = common.get_tree_node(tree, 6)
self.assertEqual(tree, Solution().lowestCommonAncestor(tree, p, q))
def test_solution(self):
self.assertEqual(
True,
Solution().isSameTree(common.create_binary_tree([1, 2, 3]),
common.create_binary_tree([1, 2, 3])))
self.assertEqual(
False,
Solution().isSameTree(common.create_binary_tree([1, 2]),
common.create_binary_tree([1, None, 2])))
self.assertEqual(
False,
Solution().isSameTree(common.create_binary_tree([1, 2, 1]),
common.create_binary_tree([1, 1, 2])))
def test_solution(self):
codec = Codec()
root = common.create_binary_tree([1, 2, 3, None, None, 4, 5])
self.assertEqual([1, 2, 3, None, None, 4, 5],
common.convert_binary_tree_to_list(
codec.deserialize(codec.serialize(root))))
def test_solution(self):
self.assertEqual(
3,
Solution().maxDepth(
common.create_binary_tree([3, 9, 20, None, None, 15, 7])))
def test_solution(self):
tree = common.create_binary_tree([1, 2, 5, 3, 4, None, 6])
Solution().flatten(tree)
self.assertEqual([1, None, 2, None, 3, None, 4, None, 5, None, 6],
common.convert_binary_tree_to_list(tree))
def test_solution(self):
self.assertEqual([[3], [9, 20], [15, 7]],
Solution().levelOrder(
common.create_binary_tree(
[3, 9, 20, None, None, 15, 7])))
def test_solution(self):
self.assertEqual([1, 2, 3],
Solution().preorderTraversal(
common.create_binary_tree([1, None, 2, 3])))
def test_solution(self):
self.assertEqual(
3,
Solution().largestBSTSubtree(
common.create_binary_tree([10, 5, 15, 1, 8, None, 7])))
def test_solution(self):
self.assertEqual(
[4, 7, 2, 9, 6, 3, 1],
common.convert_binary_tree_to_list(Solution().invertTree(
common.create_binary_tree([4, 2, 7, 1, 3, 6, 9]))))
def test_solution(self):
self.assertEqual(
6,
Solution().countNodes(common.create_binary_tree([1, 2, 3, 4, 5,
6])))
def test_solution(self):
self.assertEqual([1, 3, 4],
Solution().rightSideView(
common.create_binary_tree(
[1, 2, 3, None, 5, None, 4])))
