def test_first_example(self):
root = TreeNode(6)
root.left = TreeNode(2)
root.left.left = TreeNode(0)
root.left.right = TreeNode(4)
root.left.right.left = TreeNode(3)
root.left.right.right = TreeNode(5)
root.right = TreeNode(8)
root.right.left = TreeNode(7)
root.right.right = TreeNode(9)
self.assertEqual(Solution().lowestCommonAncestor(root, root.left, root.right), root)
def test_left_leaning_tree(self):
original_root = TreeNode(1)
original_root.left = TreeNode(2)
original_root.left.left = TreeNode(3)
original_root.left.left.left = TreeNode(4)
original_root.left.left.left.left = TreeNode(5)
serialized = '{"l1": {"l2": {"l3": {"l4": {"l5": {}}}}}}'
self.assertEqual(Codec().serialize(original_root), serialized)
root = Codec().deserialize(serialized)
self.assertEqual(root.val, 1)
self.assertEqual(root.left.val, 2)
self.assertEqual(root.left.left.val, 3)
self.assertEqual(root.left.left.left.val, 4)
self.assertEqual(root.left.left.left.left.val, 5)
def test_first_example(self):
root = TreeNode(5)
root.left = TreeNode(4)
root.left.left = TreeNode(11)
root.left.left.left = TreeNode(7)
root.left.left.right = TreeNode(2)
root.right = TreeNode(8)
root.right.left = TreeNode(13)
root.right.right = TreeNode(4)
root.right.right.right = TreeNode(1)
self.assertTrue(Solution().hasPathSum(root, 22))
def constructMaximumBinaryTree(self,
nums: List[int]) -> Optional[TreeNode]:
if not nums:
return None
if len(nums) == 1:
return TreeNode(nums[0])
maximum = 0
for i in range(1, len(nums)):
if nums[i] > nums[maximum]:
maximum = i
node = TreeNode(nums[maximum])
node.left = self.constructMaximumBinaryTree(nums[:maximum])
node.right = self.constructMaximumBinaryTree(nums[maximum + 1:])
return node
def test_first_example(self):
root = TreeNode(0)
root.left = TreeNode(1)
root.right = TreeNode(2)
root.left.left = TreeNode(3)
root.left.right = TreeNode(4)
root.right.left = TreeNode(3)
root.right.right = TreeNode(4)
self.assertEqual(Solution().smallestFromLeaf(root), 'dba')
def test_first_example(self):
root = TreeNode(5)
root.left = TreeNode(4)
root.left.left = TreeNode(11)
root.left.left.left = TreeNode(7)
root.left.left.right = TreeNode(2)
root.right = TreeNode(8)
root.right.left = TreeNode(13)
root.right.right = TreeNode(4)
root.right.right.left = TreeNode(5)
root.right.right.right = TreeNode(1)
expected = [
[5, 4, 11, 2],
[5, 8, 4, 5]
]
self.assertListEqual(Solution().pathSum(root, 22), expected)
def test_fourth_example(self):
root1 = TreeNode(0)
root1.left = TreeNode(3)
root1.right = TreeNode(1)
root1.right.right = TreeNode(2)
root2 = TreeNode(0)
root2.left = TreeNode(3)
root2.right = TreeNode(1)
root2.left.left = TreeNode(2)
self.assertFalse(Solution().flipEquiv(root1, root2))
def test_second_example(self):
root = TreeNode(25)
root.left = TreeNode(1)
root.right = TreeNode(3)
root.left.left = TreeNode(1)
root.left.right = TreeNode(3)
root.right.left = TreeNode(0)
root.right.right = TreeNode(2)
self.assertEqual(Solution().smallestFromLeaf(root), 'adz')
def test_first_example(self):
root = TreeNode(4)
root.left = TreeNode(1)
root.left.left = TreeNode(0)
root.left.right = TreeNode(2)
root.left.right.right = TreeNode(3)
root.right = TreeNode(6)
root.right.left = TreeNode(5)
root.right.right = TreeNode(7)
root.right.right.right = TreeNode(8)
updated_root = Solution().bstToGst(root)
self.assertEqual(root.right.left.val, 26)
self.assertEqual(updated_root.val, 30)
self.assertEqual(updated_root.left.right.right.val, 33)
self.assertEqual(updated_root.left.right.val, 35)
self.assertEqual(updated_root.left.left.val, 36)
def test_first_example(self):
root = TreeNode(1)
root.left = TreeNode(0)
root.right = TreeNode(1)
root.left.left = TreeNode(0)
root.left.right = TreeNode(1)
root.right.left = TreeNode(0)
root.right.right = TreeNode(1)
self.assertEqual(Solution().sumRootToLeaf(root), 22)
def test_first_example(self):
root = TreeNode(1)
root.left = TreeNode(2)
root.left.left = TreeNode(3)
root.left.right = TreeNode(4)
root.right = TreeNode(2)
root.right.right = TreeNode(3)
root.right.left = TreeNode(4)
self.assertTrue(Solution().isSymmetric(root))
def test_unbalanced_tree(self):
root = TreeNode(1)
root.left = TreeNode(2)
root.right = TreeNode(2)
root.left.left = TreeNode(3)
root.left.right = TreeNode(3)
root.left.left.left = TreeNode(4)
root.left.left.right = TreeNode(4)
self.assertFalse(Solution().isBalanced(root))
def test_second_example(self):
root = TreeNode(1)
root.left = TreeNode(2)
root.left.left = TreeNode(4)
root.right = TreeNode(3)
root.right.left = TreeNode(5)
root.right.right = TreeNode(6)
root.right.left.left = TreeNode(7)
self.assertEqual(Solution().findBottomLeftValue(root), 7)
def test_second_example(self):
root = TreeNode(1)
root.right = TreeNode(0)
root.right.right = TreeNode(1)
root.right.left = TreeNode(0)
root.left = TreeNode(1)
root.left.left = TreeNode(1)
root.left.right = TreeNode(1)
root.left.left.left = TreeNode(0)
Solution().pruneTree(root)
self.assertIsNone(root.left.left.left)
self.assertIsNone(root.right.left)
def test_first_example(self):
root = TreeNode(1)
root.left = TreeNode(2)
root.right = TreeNode(3)
root.left.left = TreeNode(4)
root.left.right = TreeNode(5)
root.right.left = TreeNode(6)
root.right.right = TreeNode(7)
expected = [root, root.right.left, root.right.right]
self.assertListEqual(Solution().delNodes(root, [3, 5]), expected)
def test_second_example(self):
root = TreeNode(5)
root.left = TreeNode(3)
root.right = TreeNode(6)
root.left.left = TreeNode(2)
root.left.right = TreeNode(4)
root.left.left.left = TreeNode(1)
self.assertEqual(Solution().kthSmallest(root, 3), 3)
def test_univalued_tree(self):
root = TreeNode(1)
root.left = TreeNode(1)
root.right = TreeNode(1)
root.left.left = TreeNode(1)
root.left.right = TreeNode(1)
root.right.right = TreeNode(1)
self.assertTrue(Solution().isUnivalTree(root))
def test_first_example(self):
root = TreeNode(10)
root.left = TreeNode(5)
root.right = TreeNode(15)
root.left.left = TreeNode(3)
root.left.right = TreeNode(7)
root.right.right = TreeNode(18)
self.assertEqual(Solution().rangeSumBST(root, 7, 15), 32)
def test_first_example(self):
root1 = TreeNode(1)
root1.left = TreeNode(3)
root1.right = TreeNode(2)
root1.left.left = TreeNode(5)
root2 = TreeNode(2)
root2.left = TreeNode(1)
root2.right = TreeNode(3)
root2.left.right = TreeNode(4)
root2.right.right = TreeNode(7)
merged_root = Solution().mergeTrees(root1, root2)
self.assertEqual(merged_root.val, 3)
self.assertEqual(merged_root.left.val, 4)
self.assertEqual(merged_root.right.val, 5)
self.assertEqual(merged_root.left.left.val, 5)
self.assertEqual(merged_root.left.right.val, 4)
self.assertEqual(merged_root.right.right.val, 7)
def deserialize(self, data: str) -> TreeNode:
def dict_as_tree(tree: Dict, node: TreeNode) -> TreeNode:
"""Converts the dictionary into a tree"""
for value, children in tree.items():
if value[0] == 'l':
node.left = TreeNode(int(value[1:]))
dict_as_tree(children, node.left)
else:
node.right = TreeNode(int(value[1:]))
dict_as_tree(children, node.right)
return node
fake_root = TreeNode(None)
return dict_as_tree(json.loads(data), fake_root).left
def test_third_example(self):
root_p = TreeNode(1)
root_p.right = TreeNode(1)
root_p.left = TreeNode(2)
root_q = TreeNode(1)
root_q.right = TreeNode(2)
root_q.left = TreeNode(1)
self.assertFalse(Solution().isSameTree(root_p, root_q))
def test_first_example(self):
root_p = TreeNode(1)
root_p.right = TreeNode(3)
root_p.left = TreeNode(2)
root_q = TreeNode(1)
root_q.right = TreeNode(3)
root_q.left = TreeNode(2)
self.assertTrue(Solution().isSameTree(root_p, root_q))
def test_first_example(self):
root = TreeNode(4)
root.left = TreeNode(2)
root.left.left = TreeNode(1)
root.left.right = TreeNode(3)
root.right = TreeNode(7)
root.right.left = TreeNode(6)
root.right.right = TreeNode(9)
inverted = Solution().invertTree(root)
self.assertEqual(inverted.val, 4)
self.assertEqual(inverted.left.val, 7)
self.assertEqual(inverted.left.left.val, 9)
self.assertEqual(inverted.left.right.val, 6)
self.assertEqual(inverted.right.val, 2)
self.assertEqual(inverted.right.left.val, 3)
self.assertEqual(inverted.right.right.val, 1)
def test_basic_example(self):
root = TreeNode(4)
root.left = TreeNode(2)
root.right = TreeNode(6)
root.left.left = TreeNode(3)
root.left.right = TreeNode(1)
root.right.left = TreeNode(5)
root = Solution().addOneRow(root, 1, 2)
self.assertEqual(root.left.val, 1)
self.assertEqual(root.right.val, 1)
self.assertEqual(root.left.left.val, 2)
self.assertIsNone(root.left.right)
self.assertEqual(root.right.right.val, 6)
self.assertEqual(root.right.right.left.val, 5)
self.assertIsNone(root.right.left)
def test_first_example(self):
root = TreeNode(7)
root.left = TreeNode(3)
root.left.right = TreeNode(4)
root.right = TreeNode(15)
root.right.left = TreeNode(9)
root.right.right = TreeNode(20)
iterator = BSTIterator(root)
self.assertEqual(iterator.next(), 3)
self.assertEqual(iterator.next(), 4)
self.assertEqual(iterator.next(), 7)
self.assertTrue(iterator.hasNext())
self.assertEqual(iterator.next(), 9)
self.assertTrue(iterator.hasNext())
self.assertEqual(iterator.next(), 15)
self.assertTrue(iterator.hasNext())
self.assertEqual(iterator.next(), 20)
self.assertFalse(iterator.hasNext())
def test_second_example(self):
root1 = None
root2 = TreeNode(1)
self.assertFalse(Solution().flipEquiv(root1, root2))
def test_second_example(self):
root = TreeNode(1)
root.left = TreeNode(2)
self.assertListEqual(Solution().rightSideView(root), [1, 2])
def test_true_example(self):
root = TreeNode(2)
root.left = TreeNode(1)
root.right = TreeNode(3)
self.assertTrue(Solution().isValidBST(root))
def test_recursive_solution(self):
root = TreeNode(1)
root.right = TreeNode(2)
root.right.left = TreeNode(3)
self.assertListEqual(Solution().preorderTraversalRecursive(root), [1, 2, 3])
def test_first_example_with_iterative_solution(self):
root = TreeNode(1)
root.right = TreeNode(2)
root.right.left = TreeNode(3)
self.assertListEqual(Solution().preorderTraversalIterative(root), [1, 2, 3])