path = []
self.helper(root, sum, path, out)
return out
def helper(self, root, sum, path, out):
if root is None:
if sum == 0:
out.append(path[:])
return
path.append(root.val)
if root.left is None and root.right is None:
if sum - root.val == 0:
out.append(path[:])
else:
if root.left is not None:
self.helper(root.left, sum - root.val, path, out)
if root.right is not None:
self.helper(root.right, sum - root.val, path, out)
path.pop()
return
test = False
if test:
from TreeNode.TreeNode import arrayToTreeNode, TreeNode
tn = arrayToTreeNode([5, 4, 8, 11, None, 13, 4, 7, 2, None, None, 5, 1])
tmp = TreeNode(0)
s = Solution()
print(s.pathSum(tn, 22))
"""
def dfs(r, out):
if r is None or len(out) == 1:
return 0
found = 0
if r in [p, q]:
found += 1
for x in (r.left, r.right):
found += dfs(x, out)
if found == 2:
out.append(r)
return 0
return found
out = []
dfs(root, out)
return None if len(out) == 0 else out[0]
test = True
if test:
from TreeNode.TreeNode import arrayToTreeNode, TreeNode
tn = arrayToTreeNode([1, 2, 3, 4, 5, 6])
p = tn.left.left
q = tn
print(p,q)
tmp = TreeNode(0)
s = Solution()
print(s.lowestCommonAncestor(tn, p, q))
el, lvl = dqr.popleft()
if el.left:
dql.append([el.left, lvl + 1])
if el.right:
dql.append([el.right, lvl + 1])
print(lvl)
out[lvl].append(el.val)
if dql:
out.append([])
while dql:
el, lvl = dql.pop()
if el.right:
dqr.appendleft([el.right, lvl + 1])
if el.left:
dqr.appendleft([el.left, lvl + 1])
print(lvl)
out[lvl].append(el.val)
return out
test = False
if test:
from TreeNode.TreeNode import arrayToTreeNode, TreeNode
# tn = arrayToTreeNode([3, 9, 20, None, None, 15, 7])
tn = arrayToTreeNode([1, 2, 3])
tmp = TreeNode(0)
s = Solution()
print(s.zigzagLevelOrder(tn))
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def isSameTree(self, p, q):
"""
:type p: TreeNode
:type q: TreeNode
:rtype: bool
"""
if p is None:
return q is None
if q is None:
return p is None
return ((p.val == q.val) and self.isSameTree(p.left, q.left)
and self.isSameTree(p.right, q.right))
test = True
if test:
from TreeNode.TreeNode import arrayToTreeNode, TreeNode
t0 = arrayToTreeNode([1, None, 2, 3])
t1 = arrayToTreeNode([1, None, 2, 3])
tmp = TreeNode(0)
s = Solution()
print(s.isSameTree(t0, t1))
# inorder left root right
if len(preorder) == 0:
return None
if len(preorder) == 1:
return TreeNode(preorder[0])
# find the root in the inorder
in_root_idx = inorder.index(preorder[0])
left_tree = self.buildTree(preorder[1:in_root_idx + 1],
inorder[0:in_root_idx])
right_tree = self.buildTree(preorder[in_root_idx + 1:],
inorder[in_root_idx + 1:])
tn = TreeNode(preorder[0])
tn.left = left_tree
tn.right = right_tree
return tn
test = False
if test:
from TreeNode.TreeNode import arrayToTreeNode, TreeNode
tn = arrayToTreeNode([1, None, 2, 3])
tmp = TreeNode(0)
s = Solution()
print(s.buildTree([3, 9, 20, 15, 7], [9, 3, 15, 20, 7]))
new_right.left = root.right
new_right.right = root
root.left = None
root.right = None
return new_root, root
nr, _ = _up(r)
return nr
test = True
if test:
Input = [1, 2, 3, 4, 5]
Input = [1, 2, None, 3, None, 4]
from TreeNode.TreeNode import arrayToTreeNode, TreeNode
tn = arrayToTreeNode(Input)
tmp = TreeNode(0)
s = Solution()
#
# 1
# / \
# 2 3
# / \
# 4 5
#
# Output: return the root of the binary tree [4,5,2,#,#,3,1]
#
# 4
# / \
# 5 2
# / \
else:
left = None
if root.right:
right = self.flatten(root.right)
else:
right = None
if left:
# find rightmost
tmp = left
while tmp.right:
tmp = tmp.right
tmp.right = root
root.right = right
root.left = None
return left
else:
root.right = right
return root
test = False
if test:
from TreeNode.TreeNode import arrayToTreeNode, TreeNode
tn = arrayToTreeNode([1, 2, 5, 3, 4, None, 6])
tmp = TreeNode(0)
s = Solution()
print(s.flatten(tn))
print(tn)
#
class Solution:
def isSubtree(self, s, t):
"""
:type s: TreeNode
:type t: TreeNode
:rtype: bool
"""
def toStr(r):
if r is None:
return "-"
ll = toStr(r.left)
rr = toStr(r.right)
return "({},{},{})".format(r.val, ll, rr)
sstr = toStr(s)
tstr = toStr(t)
return tstr in sstr
test = True
if test:
from TreeNode.TreeNode import arrayToTreeNode, TreeNode
tn = arrayToTreeNode([3, 4, 5, 1, 2])
tn2 = arrayToTreeNode([4, 1, 2])
tmp = TreeNode(0)
s = Solution()
print(s.isSubtree(tn, tn2))
if p0.left:
conn.next = p0.left
conn = conn.next
if p0.right:
conn.next = p0.right
conn = conn.next
else:
if p0.left:
conn = p0.left
first = conn
if p0.right:
if conn:
conn.next = p0.right
conn = conn.next
else:
conn = p0.right
first = conn
p0 = p0.next
if first:
self.connect(first)
test = False
if test:
from TreeNode.TreeNode import arrayToTreeNode, TreeNode
tn = arrayToTreeNode([1, 2, 3, 4, None, None, 7])
tmp = TreeNode(0)
s = Solution()
print(s.connect(tn))
print(tn)
class Solution:
def countUnivalSubtrees(self, root):
def cus(root):
if root is None:
return 0, True # count and isUni
ll, iul = cus(root.left)
rr, iur = cus(root.right)
if ((iul and iur)
and ((root.left is None or root.left.val == root.val) and
(root.right is None or root.right.val == root.val))):
off = 1
iu = True
else:
off = 0
iu = False
return ll + rr + off, iu
count, _ = cus(root)
return count
test = True
if test:
from TreeNode.TreeNode import arrayToTreeNode, TreeNode
root = [5, 1, 5, 5, 5, None, 5]
tn = arrayToTreeNode(root)
tmp = TreeNode(0)
s = Solution()
print(s.countUnivalSubtrees(tn))
class Solution:
def levelOrder(self, root):
"""
:type root: TreeNode
:rtype: List[List[int]]
"""
if root is None:
return []
dq = deque()
dq.append([root, 0])
out = []
while dq:
el, lvl = dq.popleft()
if el.left:
dq.append([el.left, lvl + 1])
if el.right:
dq.append([el.right, lvl + 1])
if lvl > len(out) - 1:
out.append([])
out[lvl].append(el.val)
return out
test = False
if test:
from TreeNode.TreeNode import arrayToTreeNode, TreeNode
tn = arrayToTreeNode([])
tmp = TreeNode(0)
s = Solution()
print(s.levelOrder(tn))
:type root: TreeNode
:type k: int
:rtype: int
"""
if root is None:
return None
c = 0
out = []
def go(root):
nonlocal c
if root == None:
return
go(root.left)
c += 1
if c == k:
out.append(root.val)
go(root.right)
go(root)
return out[-1]
test = True
if test:
from TreeNode.TreeNode import arrayToTreeNode, TreeNode
tn = arrayToTreeNode([1, 2, 3, 4, 5, 6, 7, 8, 9])
tmp = TreeNode(0)
s = Solution()
print(s.kthSmallest(tn, 9))
"""
:type root: TreeNode
:rtype: int
"""
def longLeaf(r):
if r is None:
return 0, 0
ll, lp = longLeaf(r.left)
rl, rp = longLeaf(r.right)
offl, offr = 0, 0
if r.left is None:
offl = -1
if r.right is None:
offr = -1
cp = max([lp, rp, ll + rl + 2 + offl + offr])
cl = max([ll + offl, rl + offr]) + 1
print(r, cp, cl)
return cl, cp
nl, np = longLeaf(root)
return np
test = True
if test:
from TreeNode.TreeNode import arrayToTreeNode, TreeNode
tn = arrayToTreeNode([1, 2, 3, 4])
tmp = TreeNode(0)
s = Solution()
print(s.diameterOfBinaryTree(tn))
# Case 2
f, left = dfs(r.left, p)
if f:
if left is None:
return (f, r)
else:
return (f, left)
# Case 3
f, right = dfs(r.right, p)
if f:
return (f, right)
return (False, None)
f, res = dfs(root, p)
if f:
return res
else:
return None
test = True
if test:
from TreeNode.TreeNode import arrayToTreeNode, TreeNode
tn = arrayToTreeNode([5, 3, 8, 2, 4, 6, 10])
tmp = TreeNode(0)
s = Solution()
print(s.inorderSuccessor(tn, tn.right.right))
:type root: TreeNode
:rtype: int
"""
if root is None:
return []
if is_leaf(root):
return [str(root.val)]
lr = self.help(root.left) + self.help(root.right)
return [str(root.val) + x for x in lr]
def is_leaf(root):
if root.left is None and root.right is None:
return True
else:
return False
test = False
if test:
from TreeNode.TreeNode import arrayToTreeNode, TreeNode
tn = arrayToTreeNode([1, 2, 3])
tmp = TreeNode(0)
s = Solution()
print(s.sumNumbers(tn))
tn = arrayToTreeNode([4, 9, 0, 5, 1])
s = Solution()
print(s.sumNumbers(tn))
s = deque()
s.append(root)
n = deque()
out = []
while s:
while s:
el = s.popleft()
if el.left:
n.append(el.left)
if el.right:
n.append(el.right)
# print(el.val, n)
out.append(el.val)
s = n
n = deque()
return out
test = True
if test:
from TreeNode.TreeNode import arrayToTreeNode, TreeNode
tn = arrayToTreeNode([1, 2, 3, 4, 5, 6])
tn = arrayToTreeNode([1, 2, 3, None, 5, None, 4])
tmp = TreeNode(0)
s = Solution()
print(s.rightSideView(tn))
