def test_splitBST_1(self):
root = list_to_tree_node([10, 5, 20, 3, 9, 15, 25, null, null, 8, null, null, null, null, null, 6, null, null, 7])
res = Solution().splitBST(root, 6)
ans = [[5,3,6],[10,9,20,8,null,15,25,7]]
for node in res:
li = treenode_to_list(node)
self.assertTrue(li in ans)
def test_splitBST(self):
root = list_to_tree_node([4,2,6,1,3,5,7])
res = Solution().splitBST(root, 2)
ans = [[2,1],[4,3,6,null,null,5,7]]
for node in res:
li = treenode_to_list(node)
self.assertTrue(li in ans)
def test_convertBST(self):
root = list_to_tree_node(
[4, 1, 6, 0, 2, 5, 7, null, null, null, 3, null, null, null, 8])
self.assertListEqual([
30, 36, 21, 36, 35, 26, 15, null, null, null, 33, null, null, null,
8
], treenode_to_list(Solution().convertBST(root)))
def test_bstToGst(self):
input = [4, 1, 6, 0, 2, 5, 7, null, null, null, 3, null, null, null, 8]
output = [
30, 36, 21, 36, 35, 26, 15, null, null, null, 33, null, null, null,
8
]
res = Solution().bstToGst(list_to_tree_node(input))
self.assertListEqual(output, treenode_to_list(res))
def test_can_merge(self):
trees = [
list_to_tree_node([2, 1]),
list_to_tree_node([3, 2, 5]),
list_to_tree_node([5, 4])
]
res = Solution().canMerge(trees)
self.assertListEqual([3, 2, 5, 1, null, 4], treenode_to_list(res))
def test_sufficientSubset_1(self):
root = list_to_tree_node(
[5, 4, 8, 11, null, 17, 4, 7, 1, null, null, 5, 3])
self.assertListEqual(
[5, 4, 8, 11, null, 17, 4, 7, null, null, null, 5],
treenode_to_list(Solution().sufficientSubset(root, 22)))
def test_can_merge_2(self):
trees = [list_to_tree_node([7])]
res = Solution().canMerge(trees)
self.assertListEqual([7], treenode_to_list(res))
def test_removeLeafNodes_4(self):
root = list_to_tree_node([1, 2, 3])
res = treenode_to_list(Solution().removeLeafNodes(root, 1))
self.assertListEqual([1, 2, 3], res)
def test_bstFromPreorder_1(self):
self.assertListEqual([4, 2],
treenode_to_list(Solution().bstFromPreorder(
[4, 2])))
def test_sufficientSubset(self):
root = list_to_tree_node(
[1, 2, 3, 4, -99, -99, 7, 8, 9, -99, -99, 12, 13, -99, 14])
self.assertListEqual([1, 2, 3, 4, null, null, 7, 8, 9, null, 14],
treenode_to_list(Solution().sufficientSubset(
root, 1)))
def test_sortedListToBST(self):
head = create_linklist_from_list([-10, -3, 0, 5, 9])
self.assertListEqual([0, -3, 9, -10, null, 5],
treenode_to_list(
Solution().sortedListToBST(head)))
def test_insertIntoMaxTree_2(self):
root = list_to_tree_node([5, 2, 3, null, 1])
self.assertListEqual([5, 2, 4, null, 1, 3],
treenode_to_list(Solution().insertIntoMaxTree(
root, 4)))
def test_insertIntoMaxTree(self):
root = list_to_tree_node([4, 1, 3, null, null, 2])
self.assertListEqual([5, 4, null, 1, 3, null, null, 2],
treenode_to_list(Solution().insertIntoMaxTree(
root, 5)))
def test_recoverFromPreorder_2(self):
self.assertListEqual([1, 401, null, 349, 88, 90],
treenode_to_list(Solution().recoverFromPreorder(
S="1-401--349---90--88")))
def test_recoverFromPreorder(self):
self.assertListEqual([1, 2, 5, 3, 4, 6, 7],
treenode_to_list(Solution().recoverFromPreorder(
S="1-2--3--4-5--6--7")))
def test_addOneRow(self):
root = list_to_tree_node([4, 2, 6, 3, 1, 5])
self.assertListEqual([4, 1, 1, 2, null, null, 6, 3, 1, 5],
treenode_to_list(Solution().addOneRow(root, 1,
2)))
def test_lcaDeepestLeaves(self):
self.assertListEqual([1, 2, 3],
treenode_to_list(Solution().lcaDeepestLeaves(
list_to_tree_node([1, 2, 3]))))
def test_bstFromPreorder(self):
self.assertListEqual([8, 5, 10, 1, 7, null, 12],
treenode_to_list(Solution().bstFromPreorder(
[8, 5, 1, 7, 10, 12])))
def test_sufficientSubset_2(self):
root = list_to_tree_node([1, 2, -3, -5, null, 4, null])
self.assertListEqual([1, null, -3, 4],
treenode_to_list(Solution().sufficientSubset(
root, -1)))
def test_bstToGst_1(self):
input = [5, 2, 13]
output = [18, 20, 13]
self.assertListEqual(
output,
treenode_to_list(Solution().bstToGst(list_to_tree_node(input))))
def test_sufficientSubset_3(self):
root = list_to_tree_node([10, 5, 10])
self.assertListEqual([],
treenode_to_list(Solution().sufficientSubset(
root, 21)))
def test_str2tree_2(self):
res = Solution().str2tree("-4(2(3)(1))(6(5)(7))")
self.assertListEqual([-4, 2, 6, 3, 1, 5, 7], treenode_to_list(res))
def test_pruneTree(self):
input = "[1,null, 0, 0, 1]"
root = stringToTreeNode(input)
solution = Solution().pruneTree(root)
self.assertEqual([1, None, 0, None, 1], treenode_to_list(solution))
def test_constructFromPrePost(self):
self.assertListEqual([1, 2, 3, 4, 5, 6, 7],
treenode_to_list(Solution().constructFromPrePost(
pre=[1, 2, 4, 5, 3, 6, 7],
post=[4, 5, 2, 6, 7, 3, 1])))
def test_removeLeafNodes_1(self):
root = list_to_tree_node([1, 3, 3, 3, 2])
res = treenode_to_list(Solution().removeLeafNodes(root, 3))
self.assertListEqual([1, 3, null, null, 2], res)
def test_can_merge_1(self):
trees = [list_to_tree_node([5, 3, 8]), list_to_tree_node([3, 2, 6])]
res = Solution().canMerge(trees)
self.assertListEqual([], treenode_to_list(res))
def test_removeLeafNodes(self):
root = list_to_tree_node([1, 2, 3, 2, null, 2, 4])
res = treenode_to_list(Solution().removeLeafNodes(root, 2))
self.assertListEqual([1, null, 3, null, 4], res)
get_preorder(root.left)
get_preorder(root.right)
get_preorder(root)
return ','.join(res)
def deserialize(self, data):
"""Decodes your encoded data to tree.
:type data: str
:rtype: TreeNode
"""
vals = iter(data.split(','))
def helper():
val = next(vals)
if val == '#':
return
root = TreeNode(int(val))
root.left = helper()
root.right = helper()
return root
root = helper()
return root
root = list_to_tree_node([1,2,3,null,null,4,5])
ser = Codec()
deser = Codec()
res = ser.serialize(root)
print(res)
ans = deser.deserialize(res)
print(treenode_to_list(ans))
def test_str2tree(self):
res = Solution().str2tree("4(2(3)(1))(6(5))")
self.assertListEqual([4, 2, 6, 3, 1, 5], treenode_to_list(res))
def test_invertTree(self):
root = list_to_tree_node([4, 2, 7, 1, 3, 6, 9])
self.assertListEqual([4, 7, 2, 9, 6, 3, 1],
treenode_to_list(Solution().invertTree(root)))
