def treeA(): A = TreeNode(1) A.left = TreeNode(2) A.right = TreeNode(3) A.left.left = TreeNode(4) A.left.right = TreeNode(5) A.right.left = TreeNode(6) return A
def buildTree(self, preorder, inorder): # 判断叶子节点 if len(inorder) == 0: return None # 前序遍历第一个值为根节点 root = TreeNode(preorder[0]) # 查找当前子树的根节点在中序遍历的索引 mid_index = inorder.index(preorder[0]) # 递归,注意长度相等 root.left = self.buildTree(preorder[1:mid_index + 1], inorder[:mid_index]) root.right = self.buildTree(preorder[mid_index + 1:], inorder[mid_index + 1:]) return root
def flatten(self, root: TreeNode) -> None: """ Do not return anything, modify root in-place instead. """ # 左子树为空,直接考虑下个点 while root: # 记录左子树最右边节点 if root.left: pre = root.left while pre.right: pre = pre.right # 左子树最右边节点连上当前节点右子树 pre.right = root.right root.right = root.left root.left = None # 下一个 root = root.right
""" # 这题的关键在于,求一棵二叉搜索树的第k大,注意大 # 树总节点个数我们不知道,但是二叉搜索树的中序遍历是递增的,因此右中左就是递减的,因此到了第k个 就可以停下来了 from tag_tree import TreeNode class Solution: def kthLargest(self, root: TreeNode, k: int) -> int: res = [] def rmlTree(root_): if not root_: return rmlTree(root_.right) res.append(root_.val) rmlTree(root_.left) rmlTree(root) return res[k - 1] A = TreeNode(5) A.left = TreeNode(3) A.right = TreeNode(6) A.left.left = TreeNode(2) A.left.right = TreeNode(4) Solution().kthLargest(A, 3)
return else: tag -= root.val cur.append(root.val) if tag == 0 and not root.left and not root.right: res.append(cur[:]) cur.pop() return helper(root.left, tag) helper(root.right, tag) cur.pop() helper(root, sum) return res A = TreeNode(5) A.left = TreeNode(4) A.right = TreeNode(8) A.left.left = TreeNode(11) A.right.right = TreeNode(4) A.right.left = TreeNode(9) A.left.left.left = TreeNode(7) A.left.left.right = TreeNode(2) A.right.right.left = TreeNode(5) A.right.right.right = TreeNode(1) print(Solution().pathSum(A, 22))
self.helper(root, path_value, sum, path, ans) return ans def helper(self, tree_node, path_value, sum_, path, ans): if not tree_node: return path_value += tree_node.val # 压住栈 path.append(tree_node.val) # 满足条件,将path添加至ans if path_value == sum_ and not tree_node.left and not tree_node.right: ans.append(path[:]) self.helper(tree_node.left, path_value, sum_, path, ans) self.helper(tree_node.right, path_value, sum_, path, ans) # 遍历完成,减去,并且弹出 path_value -= tree_node.val path.pop() tree = TreeNode(5) tree.left = TreeNode(4) tree.left.left = TreeNode(11) tree.left.left.left = TreeNode(7) tree.left.left.right = TreeNode(2) tree.right = TreeNode(8) tree.right.left = TreeNode(13) tree.right.right = TreeNode(4) tree.right.right.left = TreeNode(5) tree.right.right.right = TreeNode(1) print(Solution().pathSum(tree, 22))
from tag_tree import TreeNode class Solution: def flatten(self, root: TreeNode) -> None: """ Do not return anything, modify root in-place instead. """ # 左子树为空,直接考虑下个点 while root: # 记录左子树最右边节点 if root.left: pre = root.left while pre.right: pre = pre.right # 左子树最右边节点连上当前节点右子树 pre.right = root.right root.right = root.left root.left = None # 下一个 root = root.right tree = TreeNode(1) tree.left = TreeNode(2) tree.left.left = TreeNode(3) tree.left.right = TreeNode(4) tree.right = TreeNode(5) tree.right.right = TreeNode(6) Solution().flatten(tree)
from tag_tree import TreeNode class Solution: def isBalanced(self, root: TreeNode) -> bool: def depth(root_): if not root_: return 0 left_depth = depth(root_.left) if left_depth == -1: return -1 right_depth = depth(root_.right) if right_depth == -1: return -1 return max(left_depth, right_depth) + 1 if abs( left_depth - right_depth) <= 1 else -1 return depth(root) != -1 A = TreeNode(1) A.left = TreeNode(2) A.left.left = TreeNode(3) A.left.left.left = TreeNode(4) A.right = TreeNode(2) A.right.right = TreeNode(3) A.right.right.right = TreeNode(4) print(Solution().isBalanced(A))
result = self.isSubTree(A, B) # 递归的判断他们各自左右节点的值是不是相同 if not result: result = self.isSubStructure(A.left, B) # 不相等则将树A的左子树与B进行比较 if not result: result = self.isSubStructure(A.right, B) # 不相等则将树A的右子树与B进行比较 return result def isSubTree(self, root_A, root_B): if not root_B: # 如果B为空,说明前面的节点都能一一对应上了,所以B是A的子树 return True if not root_A: # 如果A为空,则说明B不是他的子树 return False if root_A.val != root_B.val: # 节点值不相等,说明也不是 return False # 判断左右子树是否符合 return self.isSubTree(root_A.left, root_B.left) and self.isSubTree( root_A.right, root_B.right) # A = [3,4,5,1,2], B = [4,1] A = TreeNode(3) A.left = TreeNode(4) A.right = TreeNode(5) A.right.left = TreeNode(1) A.left.right = TreeNode(2) B = TreeNode(5) B.left = TreeNode(1) Solution().isSubStructure(A, B) Solution1().isSubStructure(A, B)