def test(self):
test_data = [
{
'p_tree_str': '[1,2,3]',
'q_tree_str': '[1,2,3]',
'expected': True
},
{
'p_tree_str': '[1,2]',
'q_tree_str': '[1,null,2]',
'expected': False
},
{
'p_tree_str': '[1,2,1]',
'q_tree_str': '[1,1,2]',
'expected': False
},
]
for data in test_data:
p_tree_str = data['p_tree_str']
q_tree_str = data['q_tree_str']
expected = data['expected']
with self.subTest(p_tree_str=p_tree_str, q_tree_str=q_tree_str):
p = deserialize_tree_str(p_tree_str)
q = deserialize_tree_str(q_tree_str)
output = self.solution.isSameTree(p, q)
self.assertEqual(output, expected)
def test(self):
test_data = [
{
'input': '[1,2,3]',
'expected': 6
},
{
'input': '[-10,9,20,null,null,15,7]',
'expected': 42
},
{
'input': '[-3]',
'expected': -3
},
{
'input': '[2,-1]',
'expected': 2
},
{
'input': '[1,-2,3]',
'expected': 4
},
{
'input': '[5,4,8,11,null,13,4,7,2,null,null,null,1]',
'expected': 48
},
]
for data in test_data:
tree_str = data['input']
expected = data['expected']
with self.subTest(tree_str=tree_str):
root = deserialize_tree_str(tree_str)
self.assertEqual(self.solution.maxPathSum(root), expected)
def test(self):
test_data = [
{
'input': '[4,2,7,1,3]',
'target': 2,
'expected': '[2,1,3]'
},
{
'input': '[4,2,7,1,3]',
'target': 100,
'expected': '[]'
},
{
'input': '[8,3,10,1,6,null,14,null,null,4,7,13]',
'target': 3,
'expected': '[3,1,6,null,null,4,7]'
},
{
'input': '[]',
'target': 0,
'expected': '[]'
},
]
for data in test_data:
tree_str = data['input']
target = data['target']
expected = data['expected']
with self.subTest(tree_str=tree_str,
target=target,
expected=expected):
root = deserialize_tree_str(tree_str)
output = self.solution.searchBST(root, target)
self.assertEqual(serialize_treenode(output), expected)
def test(self):
test_data = [
{
'input': '[]',
'expected': True
},
{
'input': '[3,9,20,null,null,15,7]',
'expected': True
},
{
'input': '[1,2,2,3,3,null,null,4,4]',
'expected': False
},
{
'input': '[1,null,2,null,3]',
'expected': False
},
]
for data in test_data:
tree_str = data['input']
expected = data['expected']
with self.subTest(tree_str=tree_str, expected=expected):
root = deserialize_tree_str(tree_str)
output = self.solution.isBalanced(root)
self.assertEqual(output, expected)
def test(self):
test_data = [
{
'input': '[]',
'expected': True
},
{
'input': '[2,1,3]',
'expected': True
},
{
'input': '[5,1,4,null,null,3,6]',
'expected': False
},
{
'input': '[1,1]',
'expected': False
},
]
for data in test_data:
tree_str = data['input']
expected = data['expected']
with self.subTest(tree_str=tree_str, expected=expected):
root = deserialize_tree_str(tree_str)
output = self.solution.isValidBST(root)
self.assertEqual(output, expected)
def test(self):
test_data = [
{
'tree_str': '[1,1,1,1,1,null,1]',
'expected': True
},
{
'tree_str': '[2,2,2,5,2]',
'expected': False
},
{
'tree_str': '[1]',
'expected': True
},
{
'tree_str': '[]',
'expected': True
},
]
for data in test_data:
tree_str = data['tree_str']
expected = data['expected']
with self.subTest(tree_str=tree_str, expected=expected):
root = deserialize_tree_str(tree_str)
output = self.solution.isUnivalTree(root)
self.assertEqual(output, expected)
def test(self):
test_data = [
{'tree_str': '[3,9,20,null,null,15,7]', 'expected': [[3], [9, 20], [15, 7]]},
]
for data in test_data:
tree_str = data['tree_str']
expected = data['expected']
with self.subTest(tree_str=tree_str):
root = deserialize_tree_str(tree_str)
output = self.solution.levelOrder(root)
self.assertEqual(output, expected)
def test(self):
test_data = [
{'input': '[4,2,7,1,3,6,9]', 'expected': '[4,7,2,9,6,3,1]'},
{'input': '[]', 'expected': '[]'},
]
for data in test_data:
tree_str = data['input']
expected = data['expected']
with self.subTest(tree_str=tree_str, expected=expected):
root = deserialize_tree_str(tree_str)
output = self.solution.invertTree(root)
self.assertEqual(serialize_treenode(output), expected)
def test(self):
test_data = [
{
'input': '[]'
},
{
'input': '[-1,0,1]'
},
{
'input': '[1,2,3,4,null,2,4,null,null,4]'
},
{
'input': '[1,2,3,null,4]'
},
{
'input': '[1,2,3,null,null,4,5]'
},
{
'input': '[1,null,2,3]'
},
{
'input': '[1,null,2,null,3]'
},
{
'input': '[2,1,3]'
},
{
'input': '[3,1,null,null,2]'
},
{
'input': '[3,2,null,1]'
},
{
'input': '[3,9,20,null,null,15,7]'
},
{
'input': '[4,2,7,1,3,6,9]'
},
{
'input': '[5,4,7,3,null,2,null,-1,null,9]'
},
{
'input': '[8,3,10,1,6,null,14,null,null,4,7,13]'
},
]
for data in test_data:
tree_str = data['input']
with self.subTest(tree_str=tree_str):
root = deserialize_tree_str(tree_str)
codec = PreorderCodec()
expected_root = codec.deserialize(codec.serialize(root))
self.assertEqual(tree_str, serialize_treenode(expected_root))
def test(self):
test_data = [
{'tree_str': '[3,1,4,null,2]', 'k': 1, 'expected': 1},
{'tree_str': '[5,3,6,2,4,null,null,1]', 'k': 3, 'expected': 3},
]
for data in test_data:
tree_str = data['tree_str']
k = data['k']
expected = data['expected']
with self.subTest(tree_str=tree_str, k=k, expected=expected):
root = deserialize_tree_str(tree_str)
output = self.solution.kthSmallest(root, k)
self.assertEqual(output, expected)
def test(self):
test_data = [
{'tree_str': '[3,9,20,null,null,15,7]', 'expected': 2},
{'tree_str': '[1]', 'expected': 1},
{'tree_str': '[]', 'expected': 0},
]
for data in test_data:
tree_str = data['tree_str']
expected = data['expected']
with self.subTest(tree_str=tree_str):
root = deserialize_tree_str(tree_str)
output = self.solution.minDepth(root)
self.assertEqual(output, expected)
def test(self):
test_data = [
{'input': '[]'},
{'input': '[-1,0,1]'},
{'input': '[1,2,3,null,null,4,5]'},
]
for data in test_data:
tree_str = data['input']
with self.subTest(tree_str=tree_str):
root = deserialize_tree_str(tree_str)
codec = Codec()
expected_root = codec.deserialize(codec.serialize(root))
self.assertEqual(tree_str, serialize_treenode(expected_root))
def test(self):
test_data = [
{
'tree_str': '[5,4,8,11,null,13,4,7,2,null,null,null,1]',
'path_sum': 22,
'expected': True
},
]
for data in test_data:
tree_str = data['tree_str']
path_sum = data['path_sum']
expected = data['expected']
with self.subTest(tree_str=tree_str, path_sum=path_sum):
root = deserialize_tree_str(tree_str)
self.assertEqual(self.solution.hasPathSum(root, path_sum),
expected)
def test(self):
test_data = [
{
'input': '[1,null,2,3]',
'expected': '[1,2,3]'
},
{
'input': '[3,2,null,1]',
'expected': '[3,2,1]'
},
{
'input': '[3,1,null,null,2]',
'expected': '[3,1,2]'
},
{
'input': '[2,1,3]',
'expected': '[2,1,3]'
},
{
'input': '[1,null,2,null,3]',
'expected': '[1,2,3]'
},
{
'input': '[1,2,3,null,null,4,5]',
'expected': '[1,2,3,4,5]'
},
{
'input': '[5,4,7,3,null,2,null,-1,null,9]',
'expected': '[5,4,3,-1,7,2,9]'
},
{
'input': '[8,3,10,1,6,null,14,null,null,4,7,13]',
'expected': '[8,3,1,6,4,7,10,14,13]'
},
{
'input': '[]',
'expected': '[]'
},
]
for data in test_data:
tree_str = data['input']
expected = data['expected']
with self.subTest(tree_str=tree_str, expected=expected):
root = deserialize_tree_str(tree_str)
output = list_to_compact_str(
self.solution.preorderTraversal(root))
self.assertEqual(output, expected)
def test(self):
test_data = [
{
'tree_str': '[1,null,2,2]',
'expected': [
2,
]
},
{
'tree_str': '[1,null,2]',
'expected': [1, 2]
},
]
for data in test_data:
tree_str = data['tree_str']
expected = data['expected']
with self.subTest(tree_str=tree_str, expected=expected):
root = deserialize_tree_str(tree_str)
output = self.solution.findMode(root)
self.assertCountEqual(output, expected)
def test(self):
test_data = [
{
'input': '[1,2,3,4,5,6]',
'expected': True
},
{
'input': '[1,2,3,4,5,null,7]',
'expected': False
},
{
'input': '[1,2,3,5,null,7,8]',
'expected': False
},
]
for data in test_data:
tree_str = data['input']
expected = data['expected']
with self.subTest(tree_str=tree_str):
root = deserialize_tree_str(tree_str)
output = self.solution.isCompleteTree(root)
self.assertEqual(output, expected)
def setUp(self):
root = deserialize_tree_str('[7,3,15,null,null,9,20]')
self.bst_iterator = BSTIterator(root)
