def levelOrder(root):
"""
:param root: TreeNode
:return: List[List[int]]
"""
result = []
if root is None:
return result
stack = [root]
while stack:
tmp = []
level = []
for node in stack:
tmp.append(node.left) if node.left else 0
tmp.append(node.right) if node.right else 0
level.append(node.val)
result.append(level)
stack = tmp
return result
if __name__ == '__main__':
print(levelOrder(TreeNode.build_tree_from_array([1])))
print(levelOrder(TreeNode.build_tree_from_array([])))
print(levelOrder(TreeNode.build_tree_from_array([3, 9, 20, '#', '#', 15, 7])))
print(levelOrder(TreeNode.build_tree_from_array([1, '#', 2, 3, '#'])))
:return: List[string]
"""
return [i for i in map(lambda x: '->'.join(x), helper(root))]
def helper(root):
if root is None:
return []
left_routes = helper(root.left)
right_routes = helper(root.right)
combine = left_routes + right_routes
if not combine:
return [[str(root.val)]]
for route in combine:
route.insert(0, str(root.val))
return combine
if __name__ == '__main__':
t = TreeNode.build_tree_from_array([1, 2, 3, 4, '#', 5, 6])
TreeNode.traverse(t)
print(helper(t))
print(binaryTreePaths(t))
"""
if root is None:
return True
depth_record = {}
return isBalanced(root.left) and isBalanced(root.right) \
and abs(depth(root.left, depth_record) - depth(root.right, depth_record)) <= 1
def depth(root, depth_dict):
"""
:param root: TreeNode
:return: int
"""
if root in depth_dict:
return depth_dict[root]
if root is None:
depth_dict[root] = 0
return 0
depth_dict[root] = 1 + max(depth(root.left, depth_dict), depth(root.right, depth_dict))
return depth_dict[root]
if __name__ == '__main__':
print(isBalanced(TreeNode.build_tree_from_array([])))
print(isBalanced(TreeNode.build_tree_from_array([1])))
print(isBalanced(TreeNode.build_tree_from_array([1, '#', 3])))
print(isBalanced(TreeNode.build_tree_from_array([1, 3, 3, '#', 2, '#', 3, 2, 3])))
def recursive(root, result):
if not root:
return
recursive(root.left, result)
result.append(root.val)
recursive(root.right, result)
def inorderTraversalIter(root):
ans = []
stack = []
while root or stack:
if root:
stack.append(root)
root = root.left
else:
node = stack.pop()
ans.append(node.val)
root = node.right
return ans
if __name__ == '__main__':
r0 = TreeNode.build_tree_from_array(['1', '#', '2', '3', '#'])
# TreeNode.traverse(r0)
print(inorderTraversalIter(r0))
to
4
/ \
7 2
/ \ / \
9 6 3 1
"""
from ltree.TreeNode import TreeNode
def invertTree(root):
if root is None:
return root
l = invertTree(root.left)
r = invertTree(root.right)
root.left = r
root.right = l
return root
if __name__ == '__main__':
root = TreeNode.build_tree_from_array([1, 2, 3])
TreeNode.traverse(root)
new_root = invertTree(root)
TreeNode.traverse(new_root)
return -999999999999
ans = max(root.val, maxVal(root.left), maxVal(root.right))
return ans
def minVal(root):
if not root:
return 9999999999999
ans = min(root.val, minVal(root.left), minVal(root.right))
return ans
if __name__ == '__main__':
r0 = TreeNode.build_tree_from_array([2, 1, 3])
# TreeNode.traverse(r0)
print(validate(r0))
# print(maxVal(r0))
# print(minVal(r0))
r1 = TreeNode.build_tree_from_array([10, 5, 15, '#', '#', 6, 20])
# TreeNode.traverse(r1)
# print(maxVal(r1))
# print(minVal(r1))
print(validate(r1))
r2 = TreeNode.build_tree_from_array([0, '#', 1])
# TreeNode.traverse(r2)
print(validate(r2))
def flatten(root):
"""
:param root:
:return:
"""
if not root:
return None
left_root = flatten(root.left)
right_root = flatten(root.right)
root.left = None
root.right = left_root
end_pointer = root
while left_root:
end_pointer = left_root
left_root = left_root.right
end_pointer.right = right_root
return root
from ltree.TreeNode import TreeNode
if __name__ == '__main__':
r0 = TreeNode.build_tree_from_array([1,2,3,4,5,6,7])
# TreeNode.traverse(r0)
TreeNode.traverse(flatten(r0))
def isSymmetricV3(root):
return True if root is None else isMirror(root.left, root.right)
def isMirror(left, right):
if left is None and right is None:
return True
if left is None or right is None:
return False
if left.val == right.val:
return isMirror(left.left, right.right) and isMirror(left.right, right.left)
else:
return False
if __name__ == "__main__":
# root = TreeNode.build_tree_from_array([1, 2, 2, 3, 4, 4, 3])
# TreeNode.traverse(root)
print(isSymmetric(TreeNode.build_tree_from_array([1, 2, 2, 3, 4, 4, 3])))
print(isSymmetric(TreeNode.build_tree_from_array([1, 2, 2, "#", 4, 4, "#"])))
print(isSymmetric(TreeNode.build_tree_from_array([1, 2, 3, 3, "#", 2, "#"])))
print(isSymmetricV3(TreeNode.build_tree_from_array([1, 2, 2, 3, 4, 4, 3])))
print(isSymmetricV3(TreeNode.build_tree_from_array([1, 2, 2, "#", 4, 4, "#"])))
print(isSymmetricV3(TreeNode.build_tree_from_array([1, 2, 3, 3, "#", 2, "#"])))
print(isSymmetricV2(TreeNode.build_tree_from_array([1, 2, 2, 3, 4, 4, 3])))
print(isSymmetricV2(TreeNode.build_tree_from_array([1, 2, 2, "#", 4, 4, "#"])))
print(isSymmetricV2(TreeNode.build_tree_from_array([1, 2, 3, 3, "#", 2, "#"])))
if reverse:
result_current_layer.reverse()
reverse = False
else:
reverse = True
ans.append(result_current_layer)
current_layer = new_layer
return ans
from ltree.TreeNode import TreeNode
if __name__ == '__main__':
r0 = TreeNode.build_tree_from_array([])
r1 = TreeNode.build_tree_from_array([1])
r2 = TreeNode.build_tree_from_array([3, 9, 20, '#', '#', 15, 7])
ans0 = zigzagLevelOrder(r0)
print(ans0)
ans1 = zigzagLevelOrder(r1)
print(ans1)
ans2 = zigzagLevelOrder(r2)
print(ans2)
return 0
return r(root, 0)
def r(root, p_value):
"""
"""
value = p_value * 10 + root.val
if (not root.left) and (not root.right):
return value
ans = 0
if root.left:
ans += r(root.left, value)
if root.right:
ans += r(root.right, value)
return ans
from ltree.TreeNode import TreeNode
if __name__ == '__main__':
r0 = TreeNode.build_tree_from_array([1, 2, 3, 4, 5])
print(sumNumbers(r0))
r1 = TreeNode.build_tree_from_array([0, 1, '#'])
print(sumNumbers(r1))
