def pasteChildren(pointer: TreeNode) -> List[TreeNode]: result = [] if pointer: if pointer.left: result.append(TreeNode(pointer.val + pointer.left.val, pointer.left.left, pointer.left.right)) if pointer.right: result.append(TreeNode(pointer.val + pointer.right.val, pointer.right.left, pointer.right.right)) return result
def buildChildTree(pre_l: int, pre_r: int, ino_l: int, ino_r: int) -> TreeNode or None: root = None if pre_l <= pre_r: root = TreeNode(preorder[pre_l]) index = dic[preorder[pre_l]] size_l = index - ino_l root.left = buildChildTree(pre_l + 1, pre_l + size_l, ino_l, ino_l + size_l - 1) root.right = buildChildTree(pre_l + 1 + size_l, pre_r, ino_l + size_l + 1, ino_r) return root
def recurseMerge(node1: TreeNode, node2: TreeNode) -> None or TreeNode: if not node1: return node2 if not node2: return node1 result = TreeNode(node1.val + node2.val) result.left = recurseMerge(node1.left, node2.left) result.right = recurseMerge(node1.right, node2.right) return result
def constructChild(the_num: List[int]) -> TreeNode or None: if the_num: index = 0 for indexes in range(0, len(the_num)): if the_num[indexes] > the_num[index]: index = indexes result = TreeNode(the_num[index]) result.left = constructChild(the_num[:index]) result.right = constructChild(the_num[index + 1:]) return result
def constructChild(left_index: int, right_index: int) -> TreeNode or None: if left_index != right_index: index = cur = left_index while cur < right_index: if nums[cur] > nums[index]: index = cur cur += 1 result = TreeNode(nums[index]) result.left = constructChild(left_index, index) result.right = constructChild(index + 1, right_index) return result
def recursion(pre: List[int], ino: List[int]) -> TreeNode or None: root = None if pre: root = TreeNode(pre[0]) index = 0 # 每次都线性查找 while index <= len(ino) - 1: if ino[index] != pre[0]: index += 1 else: break root.left = recursion(pre[1:1 + index], ino[:index]) root.right = recursion(pre[1 + index:], ino[index + 1:]) return root
def constructMaximumBinaryTree(nums: List[int]) -> TreeNode or None: if nums: nodes = [] for num in nums: cur = TreeNode(num) if not nodes or cur.val <= nodes[-1].val: nodes.append(cur) continue while cur.val > nodes[-1].val: child = nodes.pop() if not nodes or nodes[-1].val > cur.val: cur.left = child else: nodes[-1].right = child if not nodes: break nodes.append(cur) while len(nodes) > 1: child = nodes.pop() nodes[-1].right = child return nodes[0]
def recurseMerge(nodes: List[TreeNode]) -> None or TreeNode: if not nodes[0] and not nodes[1]: return result = TreeNode() left = [] right = [] if nodes[0]: result.val += nodes[0].val left.append(nodes[0].left) right.append(nodes[0].right) else: left.append(None) right.append(None) if nodes[1]: result.val += nodes[1].val left.append(nodes[1].left) right.append(nodes[1].right) else: left.append(None) right.append(None) result.left = recurseMerge(left) result.right = recurseMerge(right) return result
def pathSum(root: TreeNode, summary: int) -> List[List[int]]: def childrenSum(pointer: TreeNode, cur_sum: int, cur_path: List[int]) -> List[List[int]]: res = [] if pointer: cur = cur_path + [pointer.val] # 必须是叶子节点(左右子树为空) if cur_sum + pointer.val == summary and not pointer.left and not pointer.right: res.append(cur) cur_sum += pointer.val if pointer.left: res += childrenSum(pointer.left, cur_sum, cur) if pointer.right: res += childrenSum(pointer.right, cur_sum, cur) return res return childrenSum(root, 0, []) if __name__ == "__main__": test = TreeNode(1, TreeNode(1, TreeNode(1), TreeNode(1)), TreeNode(1, TreeNode(1), TreeNode(1))) print(pathSum(test, 3)) test2 = TreeNode(1, TreeNode(2)) print(pathSum(test2, 1)) test3 = TreeNode(1) print(pathSum(test3, 1)) test4 = TreeNode(-2, None, TreeNode(-3)) print(pathSum(test4, -5))
result = [] if root: node_list = [root] visited = [0] while node_list: if visited[0] == 0: visited[0] = 1 index = 0 if node_list[index].left: node_list.insert(0, node_list[index].left) visited.insert(0, 0) index = 1 if node_list[index].right: if index == 0: node_list.insert(1, node_list[index].right) visited.insert(1, 0) else: node_list.insert(2, node_list[index].right) visited.insert(2, 0) else: result.append(node_list[0].val) node_list.pop(0) visited.pop(0) return result if __name__ == "__main__": test = TreeNode(1, TreeNode(2, TreeNode(4), TreeNode(5)), TreeNode(3, TreeNode(6), TreeNode(7))) print(postorderTraversal(test)) # [4,2,5,1,6,3,7]
if not nodes[0] and not nodes[1]: return result = TreeNode() left = [] right = [] if nodes[0]: result.val += nodes[0].val left.append(nodes[0].left) right.append(nodes[0].right) else: left.append(None) right.append(None) if nodes[1]: result.val += nodes[1].val left.append(nodes[1].left) right.append(nodes[1].right) else: left.append(None) right.append(None) result.left = recurseMerge(left) result.right = recurseMerge(right) return result return recurseMerge([t1, t2]) if __name__ == "__main__": tree1 = TreeNode(1, TreeNode(2), TreeNode(3, TreeNode(4))) tree2 = TreeNode(1, TreeNode(2), TreeNode(3)) print(mergeTrees(tree1, tree2))
from collections import deque from typing import List def largestValues(root: TreeNode) -> List[int]: res = [] if root: node_list = deque([[root, 1]]) layers = 0 while node_list: if node_list[0][0].left: node_list.append([node_list[0][0].left, node_list[0][1] + 1]) if node_list[0][0].right: node_list.append([node_list[0][0].right, node_list[0][1] + 1]) if node_list[0][1] > layers: layers = node_list[0][1] res.append(node_list[0][0].val) else: if res[-1] < node_list[0][0].val: res[-1] = node_list[0][0].val node_list.popleft() return res if __name__ == "__main__": test = TreeNode(1, TreeNode(3, TreeNode(5), TreeNode(3)), TreeNode(2, None, TreeNode(9))) print(largestValues(test))
15 7 返回它的最大深度 3 """ # Definition for singly-linked list. from DSAA.data_structure.basic.LeetcodeNode import TreeNode def maxDepth(root: TreeNode or None) -> int: def recursion(pointer: TreeNode) -> int: left = right = 0 if pointer: if pointer.left: left = recursion(pointer.left) if pointer.right: right = recursion(pointer.right) return 1 + max(left, right) return 0 return recursion(root) if __name__ == "__main__": test = TreeNode(1, TreeNode(4), TreeNode(3)) print(maxDepth(test)) # 2 test2 = TreeNode(1, TreeNode(2, TreeNode(8, None, TreeNode(5))), TreeNode(3)) print(maxDepth(test2)) # 4 print(maxDepth(None)) # 0 test3 = TreeNode(6) print(maxDepth(test3)) # 1
返回它的最小深度 2 """ # Definition for a binary tree node. from DSAA.data_structure.basic.LeetcodeNode import TreeNode def minDepth(root: TreeNode) -> int: def childrenDepth(pointer: TreeNode) -> int: if pointer: left = right = 0 if pointer.left: left = childrenDepth(pointer.left) if pointer.right: right = childrenDepth(pointer.right) if left == 0 or right == 0: return 1 + max(left, right) else: return 1 + min(left, right) return 0 return childrenDepth(root) if __name__ == "__main__": test = TreeNode(1, TreeNode(2)) print(minDepth(test)) # 2 test2 = TreeNode(1, TreeNode(2, TreeNode(4)), TreeNode(3, None, TreeNode(5))) print(minDepth(test2)) # 3
def isLeafNode(pointer: TreeNode) -> bool: if not pointer: return False if not pointer.left and not pointer.right: return True else: return False if not root: return False else: sum_list = [] node_list = [root] node_list += pasteChildren(root) while node_list: if node_list[0]: node_list += pasteChildren(node_list[0]) if isLeafNode(node_list[0]): sum_list.append(node_list[0].val) node_list.pop(0) dic = set(sum_list) if summary in dic: return True else: return False if __name__ == "__main__": test = TreeNode(1, TreeNode(2, TreeNode(5, None, TreeNode(4))), TreeNode(3, TreeNode(2), None)) print(hasPathSum(test, 6))
""" # Definition for singly-linked list. from DSAA.data_structure.basic.LeetcodeNode import TreeNode def maxDepth(root: TreeNode or None) -> int: def recursion(pointer: TreeNode) -> int: this = 0 left = right = 0 if pointer: this = 1 if pointer.left: left = recursion(pointer.left) if pointer.right: right = recursion(pointer.right) return this + max(left, right) return recursion(root) if __name__ == "__main__": test = TreeNode(1, TreeNode(2), TreeNode(3)) print(maxDepth(test)) # 2 test2 = TreeNode(1, TreeNode(2, TreeNode(4, None, TreeNode(5))), TreeNode(3)) print(maxDepth(test2)) # 4 print(maxDepth(None)) # 0 test3 = TreeNode(5) print(maxDepth(test3)) # 1
def returnChildren(pointer: TreeNode) -> List[TreeNode]: if not pointer: return [] else: result = [] if pointer.left: result.append(pointer.left) # else: # result.append(None) if pointer.right: result.append(pointer.right) # else: # result.append(None) return result count = 0 node_list = [root] while node_list: node_pointer = node_list[0] node_list += returnChildren(node_pointer) if node_pointer: count += 1 node_list.pop(0) return count if __name__ == "__main__": tree = TreeNode(1, TreeNode(2, TreeNode(4), TreeNode(5)), TreeNode(3, TreeNode(6))) print(countNodes(tree))
# Definition for a binary tree node. from DSAA.data_structure.basic.LeetcodeNode import TreeNode def findTilt(root: TreeNode or None) -> int: def traverse(pointer: TreeNode) -> List[int]: lefts = rights = 0 tilt = val = 0 if pointer: val = pointer.val if pointer.left: left_res = traverse(pointer.left) tilt += left_res[0] lefts += left_res[1] if pointer.right: right_res = traverse(pointer.right) tilt += right_res[0] rights += right_res[1] tilt += abs(lefts - rights) return [tilt, lefts + rights + val] return traverse(root)[0] if __name__ == "__main__": test = TreeNode(1) print(findTilt(test)) test3 = TreeNode(1, TreeNode(2, TreeNode(8)), TreeNode(3)) print(findTilt(test3))
9 6 3 1 """ # Definition for a binary tree node. from DSAA.data_structure.basic.LeetcodeNode import TreeNode def invertTree(root: TreeNode) -> TreeNode: def returnChildren(pointer: TreeNode): result = [] if pointer: if pointer.left: result.append(pointer.left) if pointer.right: result.append(pointer.right) return result if root: node_list = [root] while node_list: node_list += returnChildren(node_list[0]) node_list[0].left, node_list[0].right = node_list[ 0].right, node_list[0].left node_list.pop(0) return root if __name__ == "__main__": test = TreeNode(1) print(invertTree(test))
""" # Definition for a binary tree node. from DSAA.data_structure.basic.LeetcodeNode import TreeNode from typing import List def largestValues(root: TreeNode) -> List[int]: res = [] def recursion(node: TreeNode, layers: int) -> None: if node: if len(res) < layers: res.append(node.val) else: res[layers - 1] = max(res[layers - 1], node.val) if node.left: recursion(node.left, layers + 1) if node.right: recursion(node.right, layers + 1) recursion(root, 1) return res if __name__ == "__main__": test = TreeNode(0, TreeNode(-1)) print(largestValues(test))
from DSAA.data_structure.basic.LeetcodeNode import TreeNode from Leetcode.isSubtree_572.isSubtree2 import isSubtree if __name__ == "__main__": test2 = TreeNode(1, TreeNode(1, TreeNode(1, TreeNode(1, TreeNode(1, None, TreeNode(2)))))) test1 = TreeNode(1, TreeNode(1, TreeNode(1, TreeNode(1, TreeNode(1, test2))))) print(isSubtree(test1, test2)) # True test3 = TreeNode(1, None, TreeNode(1, None, TreeNode(1, None, TreeNode(1, TreeNode(2))))) test4 = TreeNode(1, None, TreeNode(1, None, TreeNode(1, None, TreeNode(1, None, test3)))) print(isSubtree(test3, test4)) # False test5 = TreeNode(-6, TreeNode(-9, None, TreeNode(-8, None, TreeNode(-7))), TreeNode(-3, TreeNode(-4), TreeNode(1, TreeNode(0), TreeNode(5, TreeNode(2))))) test6 = TreeNode(-6, TreeNode(-9, None, TreeNode(-8, None, TreeNode(-7))), TreeNode(-3, TreeNode(-4), TreeNode(1))) print(isSubtree(test5, test6)) # False
""" import collections # Definition for a binary tree node. from DSAA.data_structure.basic.LeetcodeNode import TreeNode from typing import List def pathSum(root: TreeNode, summary: int) -> List[List[int]]: res = [] if root: node_list = collections.deque([[root, [root.val], root.val]]) while node_list: tmp = node_list.popleft() node, path, cur_sum = tmp[0], tmp[1], tmp[2] if not node.left and not node.right and cur_sum == summary: res.append(path) if node.left: node_list.append([node.left, path + [node.left.val], cur_sum + node.left.val]) if node.right: node_list.append([node.right, path + [node.right.val], cur_sum + node.right.val]) return res if __name__ == "__main__": test = TreeNode(1, TreeNode(1, TreeNode(1), TreeNode(1)), TreeNode(1, TreeNode(1), TreeNode(1))) print(pathSum(test, 3))