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)