from BinaryTree import TreeNode, listtoTreeNode, prettyPrintTree
def preorderTraversal(root):
preorder = []
stack = []
if root is None: return preorder
stack.append(root)
while len(stack) > 0:
curr = stack.pop()
preorder.append(curr.val)
if curr.right: stack.append(curr.right)
if curr.left: stack.append(curr.left)
return preorder
if __name__ == '__main__':
tree = [5, 4, 7, 3, 6, None, 2, None, -1, 2, None, None, 9]
root = listtoTreeNode(tree)
prettyPrintTree(root)
preorder = preorderTraversal(root)
print(preorder)
from BinaryTree import prettyPrintTree, listtoTreeNode
def maxDepth(root):
if root is None: return 0
depth = 1 + max(maxDepth(root.left), maxDepth(root.right))
return depth
if __name__ == '__main__':
root = listtoTreeNode([3, 9, 20, None, None, 15, 7])
prettyPrintTree(root)
print(maxDepth(root))
def isSymmetric(root):
def isMirror(left, right):
if left is None and right is None: return True
if left is None or right is None: return False
return left.val == right.val and isMirror(
left.left, right.right) and isMirror(left.right, right.left)
if root is None: return True
return isMirror(root.left, root.right)
def isSymmetric2(root):
if root is None: return True
stack = [(root.left, root.right)]
while stack:
left, right = stack.pop()
if left is None and right is None: continue
if left is None or right is None: return False
if left.val != right.val: return False
stack.append((left.left, right.right))
stack.append((left.right, right.left))
return True
if __name__ == '__main__':
root = listtoTreeNode([1, 2, 2, None, 4, 4, None])
prettyPrintTree(root)
print(isSymmetric2(root))
from BinaryTree import listtoTreeNode, prettyPrintTree
def levelOrder(root):
output = []
if root is None: return output
queue = []
queue.append(root)
while len(queue) > 0:
level_size = len(queue)
nodes_in_level = []
for _ in range(level_size):
node = queue.pop(0)
nodes_in_level.append(node.val)
if node.left:
queue.append(node.left)
if node.right:
queue.append(node.right)
output.append(nodes_in_level)
return output
if __name__ == '__main__':
l = [3,9,20,None,None,15,7]
root = listtoTreeNode(l)
prettyPrintTree(root)
print(levelOrder(root))
l = []
root = listtoTreeNode(l)
prettyPrintTree(root)
print(levelOrder(root))
from BinaryTree import prettyPrintTree, listtoTreeNode
def zigzagLevelOrder(root):
levels = []
if root is None: return levels
queue = []
queue.append(root)
while len(queue) > 0:
level = []
n = len(queue)
for _ in range(n):
node = queue.pop(0)
level.append(node.val)
if node.left: queue.append(node.left)
if node.right: queue.append(node.right)
levels.append(level)
for i, _ in enumerate(levels):
if i % 2 == 1:
levels[i] = levels[i][::-1]
return levels
if __name__ == '__main__':
# root = listtoTreeNode([3,9,20,4,6,15,7])
# prettyPrintTree(root)
# print(zigzagLevelOrder(root))
root = listtoTreeNode([1, 2, 3, 4, None, None, 5])
prettyPrintTree(root)
print(zigzagLevelOrder(root))
def isValidBST_helper(root, MIN, MAX):
if root is None: return True
if (root.val > MIN and root.val < MAX
and isValidBST_helper(root.left, MIN, root.val)
and isValidBST_helper(root.right, root.val, MAX)):
return True
return False
MIN = float('-inf')
MAX = float('inf')
return isValidBST_helper(root, MIN, MAX)
def isValidBST2(root):
curr = root
stack = []
prev_val = float("-inf")
while stack or curr:
while curr:
stack.append(curr)
curr = curr.left
node = stack.pop()
if prev_val >= node.val: return False
prev_val = node.val
curr = node.right
return True
if __name__ == '__main__':
root = listtoTreeNode([1, 0, 2])
print(isValidBST2(root))