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)