def test_preorder_traversal(self):
self.assertEqual([1, 2, 3],
Solution().preorderTraversal(
TreeNode(1, None, TreeNode(2, TreeNode(3),
None))))
self.assertEqual([], Solution().preorderTraversal(None))
self.assertEqual([1], Solution().preorderTraversal(TreeNode(1)))
def test_is_same_tree(self):
# self.assertEqual(True, Solution().isSameTree(
# TreeNode(1, TreeNode(2), TreeNode(3)),
# TreeNode(1, TreeNode(2), TreeNode(3))
# ))
self.assertEqual(False, Solution().isSameTree(
TreeNode(1, TreeNode(2)),
TreeNode(1, None, TreeNode(2))
))
def main():
# Build test tree
treeNodeHead = testTree = TreeNode(3)
testTree.left = TreeNode(9)
testTree.right = TreeNode(20)
testTree = testTree.right
testTree.left = TreeNode(15)
testTree.right = TreeNode(7)
placeholder = testTree
testTree = testTree.left
testTree.left = TreeNode(77)
testTree.right = TreeNode(88)
testTree = placeholder
testTree = testTree.right
testTree.left = TreeNode(33)
testTree.right = TreeNode(44)
# Point to the head before passing to the Solution class
testTree = treeNodeHead
# Instantiate Solution class
s = Solution()
# Run the solution
answer = s.maxDepth(testTree)
print("Max depth of the binary tree: " + str(answer))
def main():
# Example 1
# Create first list node and set the head pointer there
treeNodeHead = testTree = TreeNode(4)
testTree.left = TreeNode(2)
testTree.right = TreeNode(7)
testTree = testTree.left
testTree.left = TreeNode(1)
testTree.right = TreeNode(3)
testTree = treeNodeHead
testTree = testTree.right
testTree.left = TreeNode(6)
testTree.right = TreeNode(9)
testTree = treeNodeHead
# Example 2
#treeNodeHead = testTree = TreeNode(2)
#testTree.left = TreeNode(1)
#testTree.right = TreeNode(3)
# Example 3
#treeNodeHead = testTree = TreeNode()
# Instantiate Solution class
s = Solution()
# Run the solution
answer = s.invertTree(testTree)
allVals = []
collectValuesInTree(answer, allVals)
print("Print all values of inverted tree: ")
print(allVals)
def test_max_depth(self):
self.assertEqual(3, Solution().maxDepth(
TreeNode(3,
TreeNode(9),
TreeNode(20,
TreeNode(15),
TreeNode(7)
)
)
))
self.assertEqual(2, Solution().maxDepth(
TreeNode(1,
None,
TreeNode(2)
)))
self.assertEqual(1, Solution().maxDepth(
TreeNode(3)
))
self.assertEqual(0, Solution().maxDepth(
None
))
def main():
# Example 1
# Create first list node and set the head pointer there
treeNodeHead = testTree = TreeNode(2)
testTree.left = TreeNode(1)
testTree.right = TreeNode(3)
# Example 2
treeNodeHead = testTree = TreeNode(5)
testTree.left = TreeNode(1)
testTree.right = TreeNode(4)
testTree = testTree.right
testTree.left = TreeNode(3)
testTree.right = TreeNode(6)
testTree = treeNodeHead
# Instantiate Solution class
s = Solution()
# Run the solution
answer = s.isValidBST(testTree)
print("This is a valid BST: ")
print(answer)
def test_has_path_sum(self):
self.assertEqual(True, Solution().hasPathSum(
TreeNode(5,
TreeNode(4,
TreeNode(11,
TreeNode(7),
TreeNode(2)
)
),
TreeNode(8,
TreeNode(13),
TreeNode(4,
TreeNode(1))
)
),
22
))
self.assertEqual(False,Solution().hasPathSum(
TreeNode(1,
TreeNode(2)
),
1
))
def test_min_depth(self):
self.assertEqual(
2,
Solution().minDepth(
TreeNode(3, TreeNode(9), TreeNode(20, TreeNode(15),
TreeNode(7)))))
self.assertEqual(
5,
Solution().minDepth(
TreeNode(
2, None,
TreeNode(3, None,
TreeNode(4, None, TreeNode(5, None,
TreeNode(6)))))))
self.assertEqual(1, Solution().minDepth(TreeNode(2)))
from Solution import BSTIterator
from Solution import TreeNode
def iterateTree(node):
# Your BSTIterator will be called like this:
i, v = BSTIterator(node), []
while i.hasNext():
v.append(i.next())
print v
root = TreeNode(6)
iterateTree(root)
root.left = TreeNode(3)
root.right = TreeNode(7)
iterateTree(root)
root.left.left = TreeNode(2)
root.left.right = TreeNode(4)
root.right = TreeNode(8)
root.right.left = TreeNode(7)
root.right.right = TreeNode(9)
iterateTree(root)
def test_is_balanced(self):
self.assertEqual(True, Solution().isBalanced(
TreeNode(3,
TreeNode(9),
TreeNode(20,
TreeNode(15),
TreeNode(7)
)
)
))
self.assertEqual(False, Solution().isBalanced(
TreeNode(1,
TreeNode(2,
TreeNode(3,
TreeNode(4),
TreeNode(4)
),
TreeNode(3)
),
TreeNode(2))
))
self.assertEqual(False, Solution().isBalanced(
TreeNode(val=1,
left=TreeNode(val=2,
left=TreeNode(val=3,
left=TreeNode(val=4,
left=None,
right=None),
right=None),
right=None),
right=TreeNode(val=2,
left=None,
right=TreeNode(val=3,
left=None,
right=TreeNode(val=4,
left=None,
right=None))))
))
def test_postorder_traversal(self):
self.assertEqual([3, 2, 1],
Solution().postorderTraversal(
TreeNode(1, None, TreeNode(2, TreeNode(3),
None))))