node = q.popleft()
row.append(node.val)
if node.left:
q.append(node.left)
if node.right:
q.append(node.right)
else:
node = q.pop()
row.append(node.val)
if node.right:
q.appendleft(node.right)
if node.left:
q.appendleft(node.left)
order = -order
res.append(row)
return res
s = Solution()
root = createTree([1, 2, 3, 4, '#', '#', 5, '#', '#', 6, 7, '#', '#', '#', 8])
root.prettyPrint()
print(s.zigzagLevelOrder(root))
root = createTree([1, 2, '#', '#', 3, 4, 5, '#', '#', 6, 7, 8, 9])
root.prettyPrint()
print(s.zigzagLevelOrder(root))
root = createTree([3, 9, 20, '#', '#', 15, 7])
print(s.zigzagLevelOrder(root))
fpath))
load_src("helper", "../helper.py")
from helper import TreeNode, createTree
class Solution:
"""
@param root: the root of binary tree.
@return: An integer
"""
def maxPathSum2(self, root):
# write your code here
if not root:
return 0
left = self.maxPathSum2(root.left)
right = self.maxPathSum2(root.right)
return max(left + root.val, right + root.val, root.val)
s = Solution()
root = createTree([-1, -3, -7])
root.prettyPrint()
print(s.maxPathSum2(root))
root = createTree([1, 2, 3])
root.prettyPrint()
print(s.maxPathSum2(root))
return None
if value < root.val:
root.left = self.removeNode(root.left, value)
elif value > root.val:
root.right = self.removeNode(root.right, value)
else:
if root.left and root.right:
max = self.findMax(root)
root.val = max.val
root.left = self.removeNode(root.left, max.val)
elif root.left:
root = root.left
elif root.right:
root = root.right
else:
root = None
return root
def findMax(self, root):
node = root.left
while node.right:
node = node.right
return node
s = Solution()
root = createTree([5, 3, 6, 2, 4])
root = s.removeNode(root, 3)
root.prettyPrint()
class Solution:
"""
@param root: The root of binary tree.
@return: An integer
"""
def maxPathSum(self, root):
# write your code here
self.res = -math.inf
self.helper(root)
return self.res
def helper(self, root):
if not root:
return 0
left = self.helper(root.left)
right = self.helper(root.right)
self.res = max(self.res, left + right + root.val, left + root.val,
right + root.val, root.val)
return max(left + root.val, right + root.val, root.val)
s = Solution()
root = createTree([1, 2, -5, 4, '#', 5, 6])
root.prettyPrint()
print(s.maxPathSum(root))
root = createTree([1, 2, 3])
root.prettyPrint()
print(s.maxPathSum(root))
def dfs(self, root):
if not root:
return
elif not root.left:
self.dfs(root.right)
elif not root.right:
root.right = root.left
root.left = None
self.dfs(root.right)
else:
node = root.left
while node.right:
node = node.right
node.right = root.right
root.right = root.left
root.left = None
self.dfs(root.right)
s = Solution()
root = createTree([7, -10, 2, -4, 3, -8, '#', '#', '#', '#', -1, 11])
root.prettyPrint()
s.flatten(root)
root.prettyPrint()
root = createTree([1, 2, 5, 3, 4, '#', 6])
root.prettyPrint()
s.flatten(root)
root.prettyPrint()
load_src("helper", "../helper.py")
from helper import TreeNode, createTree
class Solution:
"""
@param: root: The root of the BST.
@param: p: You need find the successor node of p.
@return: Successor of p.
"""
def inorderSuccessor(self, root, p):
# write your code here
sucessor = None
while root:
if root.val > p.val:
sucessor = root
root = root.left
elif root.val <= p.val:
root = root.right
return sucessor
s = Solution()
root = createTree([2, 1, 4, '#', '#', 3, 5])
root.prettyPrint()
print(s.inorderSuccessor(root, root).val)
print(s.inorderSuccessor(root, root.left).val)
print(s.inorderSuccessor(root, root.right).val)
import os
import imp
return imp.load_source(name, os.path.join(os.path.dirname(__file__), fpath))
load_src("helper", "../helper.py")
from helper import TreeNode, createTree
class Solution:
"""
@param root: root of the given tree
@return: whether it is a mirror of itself
"""
def isSymmetric(self, root):
# Write your code here
if not root:
return True
return self.helper(root.left, root.right)
def helper(self, left, right):
if left is None or right is None:
return left == right
if left.val != right.val:
return False
return self.helper(left.left, right.right) and self.helper(left.right, right.left)
s = Solution()
root = createTree([1, 2, 2, 3, 4, 4, 3])
root.prettyPrint()
print(s.isSymmetric(root))
def load_src(name, fpath):
import os
import imp
return imp.load_source(name, os.path.join(os.path.dirname(__file__),
fpath))
load_src("helper", "../helper.py")
from helper import TreeNode, createTree
class Solution:
"""
@param root: The root of binary tree.
@return: An integer
"""
def maxDepth(self, root):
# write your code here
if not root:
return 0
return max(self.maxDepth(root.left), self.maxDepth(root.right)) + 1
s = Solution()
root = createTree([1, '#', 2, 3])
print(s.maxDepth(root))
root = createTree([1, 2, 3, '#', '#', 4, 5])
print(s.maxDepth(root))
@param root: A Tree
@return: Postorder in ArrayList which contains node values.
"""
def postorderTraversal(self, root):
# write your code here
res = []
s = []
cur = root
while s or cur:
while cur:
s.append(cur)
cur = cur.left if cur.left else cur.right
cur = s.pop()
res.append(cur.val)
if s and s[-1].left == cur:
cur = s[-1].right
else:
cur = None
return res
s = Solution()
root = createTree([1, 2, 3, 4, 5, 6, 7, 8])
root.prettyPrint()
print(s.postorderTraversal(root))
root = createTree([1, 2, 3, '#', '#', 4, 5])
root.prettyPrint()
print(s.postorderTraversal(root))
class Solution:
"""
@param root: param root: The root of the binary search tree
@param k1: An integer
@param k2: An integer
@return: return: Return all keys that k1<=key<=k2 in ascending order
"""
def searchRange(self, root, k1, k2):
# write your code here
res = []
self.helper(res, root, k1, k2)
return res
def helper(self, res, root, k1, k2):
if not root:
return
if root.val < k1:
self.helper(res, root.right, k1, k2)
elif root.val > k2:
self.helper(res, root.left, k1, k2)
else:
self.helper(res, root.left, k1, k2)
res.append(root.val)
self.helper(res, root.right, k1, k2)
s = Solution()
root = createTree([20, 8, 22, 4, 12])
root.prettyPrint()
print(s.searchRange(root, 10, 22))
def longestConsecutive2(self, root):
# write your code here
self.longest = 0
self.helper(root)
return self.longest
def helper(self, root):
if not root:
return (0, 0)
up, down = 0, 0
left_up, left_down = self.helper(root.left)
right_up, right_down = self.helper(root.right)
if root.left:
if root.val + 1 == root.left.val:
up = max(up, left_up + 1)
if root.val - 1 == root.left.val:
down = max(down, left_down + 1)
if root.right:
if root.val + 1 == root.right.val:
up = max(up, right_up + 1)
if root.val - 1 == root.right.val:
down = max(down, right_down + 1)
self.longest = max(self.longest, up + down + 1)
return (up, down)
s = Solution()
root = createTree([1, 2, 0, 3])
root.prettyPrint()
print(s.longestConsecutive2(root))
"""
@param: root: the root of binary tree
@param: target: An integer
@return: all valid paths
"""
def binaryTreePathSum2(self, root, target):
# write your code here
res = []
self.helper(root, target, res, [])
return res
def helper(self, root, target, res, path):
if not root:
return
path.append(root.val)
sum = 0
for i in range(len(path) - 1, -1, -1):
sum += path[i]
if sum == target:
res.append(path[i:])
self.helper(root.left, target, res, path)
self.helper(root.right, target, res, path)
path.pop()
s = Solution()
root = createTree([1, 2, 3, 4, '#', 2])
root.prettyPrint()
print(s.binaryTreePathSum2(root, 6))
class Solution:
"""
@param root: the root of the binary tree
@return: all root-to-leaf paths
"""
def binaryTreePaths(self, root):
# write your code here
res = []
cur = []
if not root:
return res
self.dfs(root, res, cur)
return res
def dfs(self, root, res, cur):
cur.append(str(root.val))
if not root.left and not root.right:
res.append('->'.join(cur))
if root.left:
self.dfs(root.left, res, cur)
cur.pop()
if root.right:
self.dfs(root.right, res, cur)
cur.pop()
s = Solution()
root = createTree([1, 2, 3, '#', 5])
print(s.binaryTreePaths(root))
def helper(self, root):
if not root:
return 0
if not root.left and not root.right:
return 1
left = self.helper(root.left)
right = self.helper(root.right)
sublongest = 1
if left and root.val + 1 == root.left.val:
sublongest = max(sublongest, left + 1)
if right and root.val + 1 == root.right.val:
sublongest = max(sublongest, right + 1)
if sublongest > self.longest:
self.longest = sublongest
return sublongest
s = Solution()
root = createTree([1, '#', 2, '#', 4, '#', 5, '#', 6])
root.prettyPrint()
print(s.longestConsecutive(root))
root = createTree([1, '#', 3, 2, 4, '#', '#', '#', 5])
root.prettyPrint()
print(s.longestConsecutive(root))
"""
def isBalanced(self, root):
# write your code here
if not root:
return True
self.res = True
self.helper(root)
return self.res
def helper(self, root):
left_height, right_height = 0, 0
if root.left:
left_height = self.helper(root.left)
if root.right:
right_height = self.helper(root.right)
if abs(left_height - right_height) > 1:
self.res = False
return 1 + max(left_height, right_height)
s = Solution()
root = createTree([3, 9, 20, '#', '#', 15, 7])
root.prettyPrint()
print(s.isBalanced(root))
root = createTree([3, '#', 20, 15, 7])
root.prettyPrint()
print(s.isBalanced(root))
class Solution:
"""
@param root: the root of binary tree
@return: the root of the maximum average of subtree
"""
def findSubtree2(self, root):
# write your code here
self.max_average = -math.inf
self.res = None
self.helper(root)
return self.res
def helper(self, root):
if not root:
return (0, 0)
left_count, left_total = self.helper(root.left)
right_count, right_total = self.helper(root.right)
count = left_count + right_count + 1
total = left_total + right_total + root.val
if total / count > self.max_average:
self.res = root
self.max_average = total / count
return (count, total)
s = Solution()
root = createTree([1, -5, 11, 1, 2, 4, -2])
root.prettyPrint()
print(s.findSubtree2(root).val)
# Write your code here
res = []
if not root:
return res
q = deque([root])
while q:
head, previous = None, None
for _ in range(len(q)):
treeNode = q.popleft()
listNode = ListNode(treeNode.val)
if not head:
head = listNode
if previous:
previous.next = listNode
previous = listNode
if treeNode.left:
q.append(treeNode.left)
if treeNode.right:
q.append(treeNode.right)
res.append(head)
return res
s = Solution()
root = createTree([1, 2, 3, 4])
res = s.binaryTreeToLists(root)
for head in res:
printList(head)
def helper(self, root, A, B):
if not root:
return False, False, None
found_a_left, found_b_left, left_lca = self.helper(root.left, A, B)
found_a_right, found_b_right, right_lca = self.helper(root.right, A, B)
found_a = found_a_left or found_a_right or A == root
found_b = found_b_left or found_b_right or B == root
if A == root or B == root:
return found_a, found_b, root
if left_lca and right_lca:
return found_a, found_b, root
if left_lca:
return found_a, found_b, left_lca
if right_lca:
return found_a, found_b, right_lca
return found_a, found_b, None
s = Solution()
root = createTree([4, 3, 7, '#', '#', 5, 6])
node3 = root.left
node7 = root.right
node5 = node7.left
node6 = node7.right
print(s.lowestCommonAncestor3(root, node3, node5).val)
print(s.lowestCommonAncestor3(root, node5, node6).val)
print(s.lowestCommonAncestor3(root, node6, node7).val)
print(s.lowestCommonAncestor3(root, node6, TreeNode(1)))
@return: Level order a list of lists of integer
"""
def levelOrder(self, root):
# write your code here
res = []
if not root:
return res
queue = deque([])
queue.appendleft(root)
while queue:
row = []
for i in range(len(queue)):
node = queue.popleft()
row.append(node.val)
if node.left:
queue.append(node.left)
if node.right:
queue.append(node.right)
res.append(row)
return res
s = Solution()
root = createTree([3, 9, 20, '#', '#', 15, 7])
root.prettyPrint()
print(s.levelOrder(root))
root = createTree([1, 2, 3])
root.prettyPrint()
print(s.levelOrder(root))
@param root: the root of binary tree
@return: the maximum weight node
"""
def findSubtree(self, root):
# write your code here
if not root:
return None
self.max = -math.inf
self.node = None
self.helper(root)
return self.node
def helper(self, root):
if not root:
return 0
left = self.helper(root.left)
right = self.helper(root.right)
sum = left + right + root.val
if sum > self.max:
self.max = sum
self.node = root
return sum
s = Solution()
root = createTree([1, '#', 2])
print(s.findSubtree(root).val)
root = createTree([1, -5, 2, 0, 3, -4, -5])
print(s.findSubtree(root).val)
