def test_case3(self):
nums = [6,5,8,1,3,7,11,None,None,None,None,None,None,9]
answer = [6,3,8,1,5,7,11,None,None,None,None,None,None,9]
root = TreeNode.generate_bt_from_list(nums)
self.sol.recoverTree(root)
compare = TreeNode.compare_tree(root, TreeNode.generate_bt_from_list(answer))
self.assertTrue(compare)
def test_case1(self):
nums = [3,1,2]
answer = [2,1,3]
root = TreeNode.generate_bt_from_list(nums)
self.sol.recoverTree(root)
compare = TreeNode.compare_tree(root, TreeNode.generate_bt_from_list(answer))
self.assertTrue(compare)
def test_case1(self):
nums = [1,None,2]
k = 2
root = TreeNode.generate_bt_from_list(nums)
answer = 2
result = self.sol.kthSmallest(root, k)
self.assertEqual(answer, result)
def test_case02(self):
nums = [2,1]
k = 1
root = TreeNode.generate_bt_from_list(nums)
answer = 1
result = self.sol.kthSmallest(root, k)
self.assertEqual(answer, result)
def test_case2(self):
nums = [5, 3, 6, 2, 4, None, 7]
target = 28
root = TreeNode.generate_bt_from_list(nums)
answer = False
result = self.sol.findTarget(root, target)
self.assertEqual(answer, result)
def test_case2(self):
nums = [1,2]
root = TreeNode.generate_bt_from_list(nums)
answer = [1,2]
self.sol.flatten(root)
result = TreeNode.get_tree_right_list(root)
self.assertEqual(answer, result)
def test_case1(self):
nums = [1, 2, 5, 3, 4, None, 6]
root = TreeNode.generate_bt_from_list(nums)
answer = [1, 2, 3, 4, 5, 6]
self.sol.flatten(root)
result = TreeNode.get_tree_right_list(root)
self.assertEqual(answer, result)
def test_case3(
self
): #=====> need to check that all the vals in subtree also smaller or greater than the ROOT val!!
nums = [10, 5, 15, None, None, 6, 20]
answer = False
result = self.sol.isValidBST(TreeNode.generate_bt_from_list(nums))
self.assertEqual(answer, result)
def test_case4(
self
): # not necessarily rob by level, see this case, can skip the level
nums = [4, 1, None, 2, None, None, None, 3]
root = TreeNode.generate_bt_from_list(nums)
answer = 7
result = self.sol.rob(root)
self.assertEqual(answer, result)
def test_case1(self):
nums = [1, 2, 3, 4, 5]
#answer = [3,1,4,None,2, None,5] # -- array way
answer = [3, 2, 5, 1, None, 4] # -- list way
result = self.sol.sortedListToBST(ListNode.parseArray2List(nums))
self.assertEqual(
True,
TreeNode.compare_tree(result,
TreeNode.generate_bt_from_list(answer)))
def test_case1(self):
nums = [3,9,20,None,None,15,7]
answer = [
[3],
[9,20],
[15,7]
]
result = self.sol.levelOrder(TreeNode.generate_bt_from_list(nums))
self.assertEqual(answer, result)
def test_case3(self):
nums = [9,
-12, -12,
32, 10, 10, 32,
None, -79, 95, 88, 88, 95, -79, None,
-90, None, 56, None, None, 50, 50, None, None, 56, None, -90]
answer = True
result = self.sol.isSymmetric(TreeNode.generate_bt_from_list(nums))
self.assertEqual(answer, result)
def test_case1(self):
nums = [1, 2, 3, None, 5]
answer = ["1->2->5", "1->3"]
result = self.sol.binaryTreePaths(TreeNode.generate_bt_from_list(nums))
self.assertEqual(answer, result)
def test_case2(self):
nums = [3, 4, 5, 1, 3, None, 1]
root = TreeNode.generate_bt_from_list(nums)
answer = 9
result = self.sol.rob(root)
self.assertEqual(answer, result)
def test_case3(self): # ===>
root = TreeNode.generate_bt_from_list(
[5, 4, 8, 11, None, 13, 4, 7, 2, None, None, None, 1])
answer = 49
result = self.sol.maxPathSum(root)
self.assertEqual(answer, result)
def test_case1(self):
nums = [1, 2, 3, 4, 5]
root = TreeNode.generate_bt_from_list(nums)
answer = 3
result = self.sol.diameterOfBinaryTree(root)
self.assertEqual(answer, result)
def test_case2(self):
nums = [1,2,3]
answer = False
result = self.sol.isValidBST(TreeNode.generate_bt_from_list(nums))
self.assertEqual(answer, result)
def test_case1(self):
nums = [1,None, 2,3]
answer = [1,2,3]
result = self.sol.preorderTraversal(TreeNode.generate_bt_from_list(nums))
self.assertEqual(answer, result)
def test_case3(self):
nums = [0,0]
root = TreeNode.generate_bt_from_list(nums)
answer = 0
result = self.sol.rob(root)
self.assertEqual(answer, result)
def test_case2(self):
nums = [3,4,5,1,3,None,1]
root = TreeNode.generate_bt_from_list(nums)
answer = 9
result = self.sol.rob(root)
self.assertEqual(answer, result)
def test_case2(self): #====>
nums = [3, 1, 2]
answer = [1, 2, 3]
result = self.sol.postorderTraversal(
TreeNode.generate_bt_from_list(nums))
self.assertEqual(answer, result)
def test_case3(self): #===> wrong for dfs
nums = [1,2]
answer = 2
result = self.sol.minDepth(TreeNode.generate_bt_from_list(nums))
self.assertEqual(answer, result)
def test_case2(self):
nums = [1,2,3,4,None]
answer = 2
result = self.sol.minDepth(TreeNode.generate_bt_from_list(nums))
self.assertEqual(answer, result)
def test_case1(self):
nums = [1,2,3]
answer = 25
result = self.sol.sumNumbers(TreeNode.generate_bt_from_list(nums))
self.assertEqual(answer, result)
def helper(root, target_val, result):
if not root:
return False
result.append(root) # should be ahead of check val
if root.val == target_val:
return True
if helper(root.left, target_val, result) or helper(root.right, target_val, result):
return True
else:
result.pop()
return False
"""
5
/ \
4 8
/ / \
11 13 14
/ \ /
7 2 15
:param list: list like this [5,4,8,11,None,13,14,7,2,None,None,None,None,15]
"""
vals = [5,4,8,11,None,13,14,7,2,None,None,None,None,15]
root = TreeNode.generate_bt_from_list(vals)
path = find_path(root, 2)
for node in path:
print(node.val)
def test_case1(self):
nums = [1, 2, 3, None, None, None, 4]
answer = 3
result = self.sol.maxDepth(TreeNode.generate_bt_from_list(nums))
self.assertEqual(answer, result)
def test_case2(self):
nums = [1,2,3,4, None, None, None, 8]
answer = False
result = self.sol.isBalanced(TreeNode.generate_bt_from_list(nums))
self.assertEqual(answer, result)
def test_case4(self): # not necessarily rob by level, see this case, can skip the level
nums = [4,1,None,2,None,None,None,3]
root = TreeNode.generate_bt_from_list(nums)
answer = 7
result = self.sol.rob(root)
self.assertEqual(answer, result)
def test_case1(self):
nums = ListNode.parseArray2List([1, 2, 3, 4, 5, 6, 7])
answer = TreeNode.generate_bt_from_list([4, 2, 6, 1, 3, 5, 7])
result = self.sol.sortedListToBST(nums)
self.assertTrue(TreeNode.compare_tree(answer, result))
def test_case5(self): # siblings can be one robbed and the other not.
nums = [1,2,3,5,4]
root = TreeNode.generate_bt_from_list(nums)
answer = 12
result = self.sol.rob(root)
self.assertEqual(answer, result)
def test_case2(self):
nums = [1,2,2,None,3,None,3]
answer = False
result = self.sol.isSymmetric(TreeNode.generate_bt_from_list(nums))
self.assertEqual(answer, result)
def test_case1(self):
nums = [1,2,3,None, None, None, 4]
answer = 3
result = self.sol.maxDepth(TreeNode.generate_bt_from_list(nums))
self.assertEqual(answer, result)
def test_case3(self): #=====> need to check that all the vals in subtree also smaller or greater than the ROOT val!!
nums = [10,5,15,None,None,6,20]
answer = False
result = self.sol.isValidBST(TreeNode.generate_bt_from_list(nums))
self.assertEqual(answer, result)
def test_case1(self):
nums = [1, 2, 3]
answer = 25
result = self.sol.sumNumbers(TreeNode.generate_bt_from_list(nums))
self.assertEqual(answer, result)
def test_case3(self): # ===>
root = TreeNode.generate_bt_from_list([5, 4, 8, 11, None, 13, 4, 7, 2, None, None, None, 1])
answer = 49
result = self.sol.maxPathSum(root)
self.assertEqual(answer, result)
def test_case1(self):
nums = ListNode.parseArray2List([1,2,3,4,5,6,7])
answer = TreeNode.generate_bt_from_list([4,2,6,1,3,5,7])
result = self.sol.sortedListToBST(nums)
self.assertTrue(TreeNode.compare_tree(answer, result))
def test_case1(self):
nums = [1,2,3,None, 5]
answer = ["1->2->5", "1->3"]
result = self.sol.binaryTreePaths(TreeNode.generate_bt_from_list(nums))
self.assertEqual(answer, result)
def test_case1(self):
nums = [1,2,3,4,5]
root = TreeNode.generate_bt_from_list(nums)
answer = 3
result = self.sol.diameterOfBinaryTree(root)
self.assertEqual(answer, result)
def test_case3(self):
nums = [0, 0]
root = TreeNode.generate_bt_from_list(nums)
answer = 0
result = self.sol.rob(root)
self.assertEqual(answer, result)
def test_case2(self):
nums = [1, 2, 3, 4, None, None, None, 8]
answer = False
result = self.sol.isBalanced(TreeNode.generate_bt_from_list(nums))
self.assertEqual(answer, result)
def test_case5(self): # siblings can be one robbed and the other not.
nums = [1, 2, 3, 5, 4]
root = TreeNode.generate_bt_from_list(nums)
answer = 12
result = self.sol.rob(root)
self.assertEqual(answer, result)
def test_case2(self):
nums = [1, 2, 3, 4, None]
answer = 2
result = self.sol.minDepth(TreeNode.generate_bt_from_list(nums))
self.assertEqual(answer, result)
def test_case1(self):
p = [1]
q = [1]
answer = True
result = self.sol.isSameTree(TreeNode.generate_bt_from_list(p), TreeNode.generate_bt_from_list(q))
self.assertEqual(answer, result)
def test_case3(self): #===> wrong for dfs
nums = [1, 2]
answer = 2
result = self.sol.minDepth(TreeNode.generate_bt_from_list(nums))
self.assertEqual(answer, result)
def helper(root, target_val, result):
if not root:
return False
result.append(root) # should be ahead of check val
if root.val == target_val:
return True
if helper(root.left, target_val, result) or helper(root.right, target_val,
result):
return True
else:
result.pop()
return False
"""
5
/ \
4 8
/ / \
11 13 14
/ \ /
7 2 15
:param list: list like this [5,4,8,11,None,13,14,7,2,None,None,None,None,15]
"""
vals = [5, 4, 8, 11, None, 13, 14, 7, 2, None, None, None, None, 15]
root = TreeNode.generate_bt_from_list(vals)
path = find_path(root, 2)
for node in path:
print(node.val)
def test_case2(self): #====>
nums = [3,1,2]
answer = [1,2,3]
result = self.sol.postorderTraversal(TreeNode.generate_bt_from_list(nums))
self.assertEqual(answer, result)
def test_case1(self):
nums = [1, None, 2, 3]
answer = [1, 2, 3]
result = self.sol.preorderTraversal(
TreeNode.generate_bt_from_list(nums))
self.assertEqual(answer, result)
def test_case2(self):
nums = [1, 2, 3]
answer = False
result = self.sol.isValidBST(TreeNode.generate_bt_from_list(nums))
self.assertEqual(answer, result)
def test_case1(self):
nums = [1,2,3,4,5]
#answer = [3,1,4,None,2, None,5] # -- array way
answer = [3,2,5,1, None,4] # -- list way
result = self.sol.sortedListToBST(ListNode.parseArray2List(nums))
self.assertEqual(True, TreeNode.compare_tree(result,TreeNode.generate_bt_from_list(answer)))
def test_case1(self):
inorder = [4,2,5,1,6,3]
postorder = [4,5,2,6,3,1]
answer = TreeNode.generate_bt_from_list([1,2,3,4,5,6])
result = self.sol.buildTree(inorder, postorder)
self.assertTrue(TreeNode.compare_tree(answer, result))