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))