def test_third_example(self):
root1 = TreeNode(0)
root1.right = TreeNode(1)
root2 = None
self.assertFalse(Solution().flipEquiv(root1, root2))
def addOneRow(self, root: TreeNode, v: int, d: int) -> TreeNode:
# Handle root replacement separately
if d == 1:
new_root = TreeNode(v)
new_root.left = root
return new_root
queue = collections.deque([(root, 1)])
while queue:
node, depth = queue.popleft()
if depth == d - 1:
temp_left = node.left
node.left = TreeNode(v)
node.left.left = temp_left
temp_right = node.right
node.right = TreeNode(v)
node.right.right = temp_right
# Nodes deeper than the target depth are irrelevant
if depth >= d:
break
if node.left:
queue.append((node.left, depth + 1))
if node.right:
queue.append((node.right, depth + 1))
return root
def test_simple_unbalanced_tree(self):
root = TreeNode(1)
root.right = TreeNode(2)
root.right.right = TreeNode(3)
self.assertFalse(Solution().isBalanced(root))
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_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 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
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_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_simple_tree(self):
original_root = TreeNode(1)
original_root.left = TreeNode(2)
serialized = Codec().serialize(original_root)
self.assertEqual(serialized, '{"l1": {"l2": {}}}')
root = Codec().deserialize(serialized)
self.assertEqual(root.val, 1)
self.assertEqual(root.left.val, 2)
self.assertIsNone(root.right)
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_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_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 invertTree(self, root: TreeNode) -> TreeNode:
if not root:
return root
temp = root.right
root.right = root.left
root.left = temp
self.invertTree(root.left)
self.invertTree(root.right)
return root
def test_false_example(self):
root = TreeNode(5)
root.left = TreeNode(1)
root.right = TreeNode(4)
root.right.left = TreeNode(3)
root.right.right = TreeNode(6)
self.assertFalse(Solution().isValidBST(root))
def test_example(self):
root = TreeNode(3)
root.left = TreeNode(9)
root.right = TreeNode(20)
root.right.left = TreeNode(15)
root.right.right = TreeNode(7)
self.assertEqual(Solution().minDepth(root), 2)
def test_example(self):
root = TreeNode(3)
root.left = TreeNode(9)
root.right = TreeNode(20)
root.right.left = TreeNode(15)
root.right.right = TreeNode(7)
expected = [[3], [9, 20], [15, 7]]
self.assertListEqual(Solution().levelOrder(root), expected)
def test_true_example(self):
root = TreeNode(1)
root.left = TreeNode(2)
root.left.right = TreeNode(4)
root.right = TreeNode(3)
root.right.right = TreeNode(5)
self.assertTrue(Solution().isCousins(root, 5, 4))
def test_regular_tree(self):
root = TreeNode(2)
root.left = TreeNode(2)
root.right = TreeNode(2)
root.left.left = TreeNode(5)
root.left.right = TreeNode(2)
self.assertFalse(Solution().isUnivalTree(root))
def test_balanced_tree(self):
root = TreeNode(3)
root.left = TreeNode(9)
root.right = TreeNode(20)
root.right.left = TreeNode(15)
root.right.right = TreeNode(7)
self.assertTrue(Solution().isBalanced(root))
def test_second_example(self):
root = TreeNode(1)
root.left = TreeNode(2)
root.left.right = TreeNode(3)
root.right = TreeNode(2)
root.right.right = TreeNode(3)
self.assertFalse(Solution().isSymmetric(root))
def test_second_example(self):
root = TreeNode(1)
root.left = TreeNode(2)
root.right = TreeNode(3)
root.left.left = TreeNode(4)
root.left.right = TreeNode(5)
self.assertEqual(Solution().sumOfLeftLeaves(root), 4)
def test_first_example(self):
root = TreeNode(3)
root.left = TreeNode(9)
root.right = TreeNode(20)
root.right.left = TreeNode(15)
root.right.right = TreeNode(7)
self.assertEqual(Solution().sumOfLeftLeaves(root), 24)
def test_serializing(self):
root = TreeNode(1)
root.left = TreeNode(2)
root.right = TreeNode(3)
root.right.left = TreeNode(4)
root.right.right = TreeNode(5)
serialized = '{"l1": {"l2": {}, "r3": {"l4": {}, "r5": {}}}}'
self.assertEqual(Codec().serialize(root), serialized)
def test_first_example(self):
root = TreeNode(3)
root.left = TreeNode(9)
root.right = TreeNode(20)
root.right.left = TreeNode(15)
root.right.right = TreeNode(7)
self.assertEqual(Solution().averageOfLevels(root), [3, 14.5, 11])
def test_second_example(self):
root_p = TreeNode(1)
root_p.left = TreeNode(2)
root_q = TreeNode(1)
root_q.right = TreeNode(2)
self.assertFalse(Solution().isSameTree(root_p, root_q))
def test_example(self):
root = TreeNode(1)
root.left = TreeNode(2)
root.left.right = TreeNode(5)
root.right = TreeNode(3)
root.right.right = TreeNode(4)
self.assertListEqual(Solution().rightSideView(root), [1, 3, 4])
def test_second_example(self):
root = TreeNode(4)
root.left = TreeNode(9)
root.right = TreeNode(0)
root.left.left = TreeNode(5)
root.left.right = TreeNode(1)
self.assertEqual(Solution().sumNumbers(root), 1026)
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)