def test_amazon(self):
s = Solution()
self.assertEqual(True, s.isValidBST(TreeNode.generate([2, 1, 3])))
self.assertEqual(
False, s.isValidBST(TreeNode.generate([5, 1, 4, None, None, 3,
6])))
def test_sum_of_left_leaves(self):
s = Solution()
self.assertEqual(0, s.sumOfLeftLeaves(TreeNode.generate([1])))
self.assertEqual(
24,
s.sumOfLeftLeaves(TreeNode.generate([3, 9, 20, None, None, 15,
7])))
def test_diameter_of_binary_tree(self):
s = Solution()
self.assertEqual(
3, s.diameterOfBinaryTree(TreeNode.generate([1, 2, 3, 4, 5])))
self.assertEqual(0, s.diameterOfBinaryTree(TreeNode.generate([])))
self.assertEqual(0, s.diameterOfBinaryTree(TreeNode.generate([1])))
self.assertEqual(1, s.diameterOfBinaryTree(TreeNode.generate([1, 2])))
def test_symmetric_tree(self):
s = Solution()
self.assertEqual(
True, s.isSymmetric(TreeNode.generate([1, 2, 2, 3, 4, 4, 3])))
self.assertEqual(
False, s.isSymmetric(TreeNode.generate([1, 2, 2, None, 3, None,
3])))
def test_microsoft(self):
s = Solution()
self.assertEqual(2, s.inorderSuccessor(TreeNode.generate([2, 1, 3]),
1))
self.assertEqual(
None,
s.inorderSuccessor(
TreeNode.generate([[5, 3, 6, 2, 4, None, None, 1]]), 6))
def test_balanced_binary_tree(self):
s = Solution()
self.assertEqual(
True, s.isBalanced(TreeNode.generate([3, 9, 20, None, None, 15,
7])))
self.assertEqual(
False,
s.isBalanced(TreeNode.generate([1, 2, 2, 3, 3, None, None, 4, 4])))
def test_binary_tree_level_order_traversal_ii(self):
s = Solution1()
self.assertEqual([[15, 7], [9, 20], [3]],
s.levelOrderBottom(
TreeNode.generate([3, 9, 20, None, None, 15, 7])))
self.assertEqual([], s.levelOrderBottom(TreeNode.generate([])))
self.assertEqual([[4, 5], [2, 3], [1]],
s.levelOrderBottom(TreeNode.generate([1, 2, 3, 4,
5])))
def test_subtree_of_another_tree(self):
s = Solution()
self.assertEqual(
True,
s.isSubtree(TreeNode.generate([3, 4, 5, 1, 2]),
TreeNode.generate([4, 1, 2])))
self.assertEqual(
False,
s.isSubtree(
TreeNode.generate([3, 4, 5, 1, 2, None, None, None, None, 0]),
TreeNode.generate([4, 1, 2])))
def test_path_sum(self):
s = Solution()
self.assertEqual(
True,
s.hasPathSum(
TreeNode.generate([
5, 4, 8, 11, None, 13, 4, 7, 2, None, None, None, None,
None, 1
]), 22))
self.assertEqual(True, s.hasPathSum(TreeNode.generate([]), 0))
self.assertEqual(False, s.hasPathSum(TreeNode.generate([]), 1))
def test_validate_binary_search_tree(self):
s = Solution()
self.assertEqual(True, s.isValidBST(TreeNode.generate([])))
self.assertEqual(True, s.isValidBST(TreeNode.generate([2, 1, 3])))
self.assertEqual(
False, s.isValidBST(TreeNode.generate([5, 1, 4, None, None, 3,
6])))
self.assertEqual(
False,
s.isValidBST(TreeNode.generate([10, 5, 15, None, None, 6, 20])))
self.assertEqual(True, s.isValidBST(TreeNode.generate([0, -1])))
def test_lowest_common_ancestor_of_a_binary_search_tree(self):
s = Solution()
self.assertEqual(
6,
s.lowestCommonAncestor(
TreeNode.generate([6, 2, 8, 0, 4, 7, 9, None, None, 3, 5]), 2,
8).val)
self.assertEqual(
2,
s.lowestCommonAncestor(
TreeNode.generate([6, 2, 8, 0, 4, 7, 9, None, None, 3, 5]), 2,
4).val)
def test_microsoft(self):
s = Solution()
self.assertEqual(
TreeNode.generate([
36, 34, 42, 33, 35, 41, 43, 32, None, None, None, 37, None,
None, 44, None, None, None, 38, None, None, None, 39, None, 40
]),
s.trimBST(
TreeNode.generate([
45, 30, 46, 10, 36, None, 49, 8, 24, 34, 42, 48, None, 4,
9, 14, 25, 31, 35, 41, 43, 47, None, 0, 6, None, None, 11,
20, None, 28, None, 33, None, None, 37, None, None, 44,
None, None, None, 1, 5, 7, None, 12, 19, 21, 26, 29, 32,
None, None, 38, None, None, None, 3, None, None, None,
None, None, 13, 18, None, None, 22, None, 27, None, None,
None, None, None, 39, 2, None, None, None, 15, None, None,
23, None, None, None, 40, None, None, None, 16, None, None,
None, None, None, 17
]), 32, 44))
self.assertEqual(
TreeNode.generate([1, None, 2]),
s.trimBST(TreeNode.generate([3, 1, 4, None, 2]), 1, 2))
self.assertEqual(TreeNode.generate([1, None, 2]),
s.trimBST(TreeNode.generate([1, 0, 2]), 1, 2))
self.assertEqual(
TreeNode.generate([3, 2, None, 1]),
s.trimBST(
TreeNode.generate(
[3, 0, 4, None, 2, None, None, None, None, 1]), 1, 3))
if __name__ == '__main__':
unittest.main()
def test_facebook(self):
s = Solution()
self.assertEqual([[9], [3, 15], [20], [7]],
s.verticalOrder(
TreeNode.generate([3, 9, 20, None, None, 15, 7])))
self.assertEqual([[4], [9], [3, 0, 1], [8], [7]],
s.verticalOrder(
TreeNode.generate([3, 9, 8, 4, 0, 1, 7])))
self.assertEqual([[4], [9, 5], [3, 0, 1], [8, 2], [7]],
s.verticalOrder(
TreeNode.generate(
[3, 9, 8, 4, 0, 1, 7, None, None, None, 2,
5])))
def test_boundary_of_binary_tree(self):
s = Solution()
self.assertEqual([1, 3, 4, 2],
s.boundaryOfBinaryTree(
TreeNode.generate([1, None, 2, None, None, 3,
4])))
self.assertEqual([1, 2, 4, 7, 8, 9, 10, 6, 3],
s.boundaryOfBinaryTree(
TreeNode.generate([
1, 2, 3, 4, 5, 6, None, None, None, 7, 8, 9,
10
])))
self.assertEqual([1], s.boundaryOfBinaryTree(TreeNode.generate([1])))
def test_binary_tree_paths(self):
s = Solution()
self.assertEqual([], s.binaryTreePaths([]))
self.assertEqual(["1->2->5", "1->3"],
s.binaryTreePaths(
TreeNode.generate([1, 2, 3, None, 5])))
def test_binary_tree_level_order_traversal(self):
s = Solution()
self.assertEqual([
[3],
[9, 20],
[15, 7]
], s.levelOrder(TreeNode.generate([3, 9, 20, None, None, 15, 7])))
def test_trim_a_binary_search_tree(self):
s = Solution()
self.assertEqual(
TreeNode.generate([1, None, 2]),
s.trimBST(TreeNode.generate([3, 1, 4, None, 2]), 1, 2))
self.assertEqual(TreeNode.generate([1, None, 2]),
s.trimBST(TreeNode.generate([1, 0, 2]), 1, 2))
self.assertEqual(
TreeNode.generate([3, 2, None, 1]),
s.trimBST(
TreeNode.generate(
[3, 0, 4, None, 2, None, None, None, None, 1]), 1, 3))
def test_same_tree(self):
s = Solution()
self.assertEqual(
True,
s.isSameTree(TreeNode.generate([1, 2, 3]),
TreeNode.generate([1, 2, 3])))
self.assertEqual(
False,
s.isSameTree(TreeNode.generate([1, 2]),
TreeNode.generate([1, None, 2])))
self.assertEqual(
False,
s.isSameTree(TreeNode.generate([1, 2, 1]),
TreeNode.generate([1, 1, 2])))
def test_convert_bst_to_greater_tree(self):
s = Solution()
self.assertEqual(TreeNode.generate([18, 20, 13]),
s.convertBST(TreeNode.generate([5, 2, 13])))
def test_minimum_depth_of_binary_tree(self):
s = Solution()
self.assertEqual(
2, s.minDepth(TreeNode.generate([3, 9, 20, None, None, 15, 7])))
self.assertEqual(2, s.minDepth(TreeNode.generate([1, 2])))
def test_merge_two_binary_trees(self):
s = Solution()
self.assertEqual(
TreeNode.generate([3, 4, 5, 5, 4, None, 7]),
s.mergeTrees(TreeNode.generate([1, 3, 2, 5]),
TreeNode.generate([2, 1, 3, None, 4, None, 7])))
def test_invert_binary_tree(self):
s = Solution()
self.assertEqual(
TreeNode.generate([4, 7, 2, 9, 6, 3, 1]),
s.invertTree(TreeNode.generate([4, 2, 7, 1, 3, 6, 9])))
def test_convert_sorted_array_to_binary_search_tree(self):
s = Solution()
self.assertEqual(TreeNode.generate([0, -3, 9, -10, None, 5]), s.sortedArrayToBST([-10, -3, 0, 5, 9]))
def test_binary_tree_inorder_traversal(self):
s = Solution()
for node in s.inorderTraversal(TreeNode.generate([1, 2, 3, 4, 5])):
print(node.val)
def test_count_complete_tree_nodes(self):
s = Solution()
self.assertEqual(0, s.countNodes(TreeNode.generate([])))
self.assertEqual(6, s.countNodes(TreeNode.generate([1, 2, 3, 4, 5,
6])))
def test_maximum_depth_of_binary_tree(self):
s = Solution()
self.assertEqual(0, s.maxDepth(TreeNode.generate([])))
self.assertEqual(
3, s.maxDepth(TreeNode.generate([3, 9, 20, None, None, 15, 7])))
def test_closest_binary_search_tree_value(self):
s = Solution()
self.assertEqual(
4, s.closestValue(TreeNode.generate([4, 2, 5, 1, 3]), 3.714286))
def test_google(self):
s = Solution()
self.assertEqual(0, s.countNodes(TreeNode.generate([])))
self.assertEqual(6, s.countNodes(TreeNode.generate([1, 2, 3, 4, 5,
6])))
def test_path_sum_iii(self):
s = Solution()
self.assertEqual(3, s.pathSum(TreeNode.generate([10, 5, -3, 3, 2, None, 11, 3, -2, None, 1]), 8))
def test_find_leaves_of_binary_tree(self):
s = Solution1()
self.assertEqual([[4, 5, 3], [2], [1]],
s.findLeaves(TreeNode.generate([1, 2, 3, 4, 5])))