def mergeTrees(t1: TreeNode, t2: TreeNode) -> TreeNode:
if t1 is None or t2 is None:
return t1 or t2
t1.val += t2.val
t1.left = mergeTrees(t1.left, t2.left)
t1.right = mergeTrees(t1.right, t2.right)
return t1
def sortedListToBST(head: 'ListNode') -> 'TreeNode':
# 难点在于如何查找链表的中间结点
# 思想，快慢指针
def find_middle(head):
slow = fast = head
prev = None
while fast and fast.next:
prev = slow
slow = slow.next
fast = fast.next.next
# 但是有个问题，left怎么遍历到mid就结束。设置prev前驱结点，保存slow指针。
# 并用下面两行代码解决这个问题，返回后的head被修改，链表被mid一分为二
if prev:
prev.next = None
return slow
if not head:
return None
mid = find_middle(head)
root = TreeNode(mid.val)
# Base case when there is just one element in the linked list
if head == mid:
return root
# 但是有个问题，left怎么遍历到mid就结束
root.left = sortedListToBST(head)
root.right = sortedListToBST(mid.next)
return root
def bstFromPreorder(A: 'List[int]') -> 'TreeNode':
if not A:
return None
p = bisect.bisect(A, A[0])
root = TreeNode(A[0])
root.left = bstFromPreorder(A[1:p])
root.right = bstFromPreorder(A[p:])
return root
def sortedArrayToBST(nums: 'List[int]') -> 'TreeNode':
if not nums:
return None
p = len(nums) // 2
root = TreeNode(nums[p])
root.left = sortedArrayToBST(nums[:p])
root.right = sortedArrayToBST(nums[p + 1:])
return root
def buildTree(preorder: 'List[int]', inorder: 'List[int]') -> 'TreeNode':
if not preorder:
return None
val = preorder[0]
root = TreeNode(val)
p = inorder.index(val)
root.left = buildTree(preorder[1:1 + p], inorder[:p])
root.right = buildTree(preorder[1 + p:], inorder[p + 1:])
return root
def buildTree(inorder: 'List[int]', postorder: 'List[int]') -> 'TreeNode':
if not inorder:
return None
val = postorder[-1]
root = TreeNode(val)
p = inorder.index(val)
root.left = buildTree(inorder[:p], postorder[:p])
root.right = buildTree(inorder[p + 1:], postorder[p:-1])
return root
def generate(first, last):
result = []
for root in range(first, last + 1):
for left in generate(first, root - 1):
for right in generate(root + 1, last):
node = TreeNode(root)
node.left = left
node.right = right
result.append(node)
return result or [None]
def ans(root):
if not root:
return None
dfs(root)
tmp = root
while tmp.left:
tmp = tmp.left
return tmp
def dfs(cur):
if not cur:
return
dfs(cur.left)
cur.left = self.pre
if self.pre:
self.pre.right = cur
self.pre = cur
dfs(cur.right)
return ans(root)
s = Solution()
root = TreeNode(10)
root.left = TreeNode(6)
root.left.left = TreeNode(4)
root.right = TreeNode(14)
root.left.right = TreeNode(8)
print(s.helper(root))
# 二叉树的镜像
from leetcode.tree import TreeNode
class Solution:
def help(self, root):
def reverse(node):
if not node:
return
tmp = node.right
node.right = node.left
node.left = tmp
reverse(node.left)
reverse(node.right)
reverse(root)
return root
s = Solution()
root = TreeNode(1)
root.right = TreeNode(2)
root.right.left = TreeNode(3)
root.right.right = TreeNode(4)
print(s.help(root))
from leetcode.tree import TreeNode
#思路 深度遍历，每往下一层+1，遍历到空返回0，返回节点左右叶子节点的大的那个数
class Solution:
def helper(self, root):
def dfs(node):
if not node:
return 0
left = dfs(node.left) + 1
right = dfs(node.right) + 1
return max(left, right)
return dfs(root)
s = Solution()
root = TreeNode(10)
root.left = TreeNode(5)
root.right = TreeNode(6)
root.left.left = TreeNode(4)
root.left.left.left = TreeNode(3)
root.left.left.right = TreeNode(2)
print(s.helper(root))
def dfs(node, sum, path):
if not node:
return
path += " " + str(node.val) + " "
cur = node.val + sum
if not node.left and not node.right and cur == value: # 1
# 打印
print(path[1:])
return
dfs(node.left, cur,path)
dfs(node.right, cur,path)
dfs(root, 0, "")
# 如果不规定路径需要从根节点开始并结束在叶子节点，思路也很简单，就是在上面的基础上，对该树每一个节点当作根节点进行调用上面的步骤，并且需要
# 除去1处代码中对叶子节点的限制
def helper1(self):
pass
s = Solution()
root = TreeNode(10)
root.left = TreeNode(5)
root.right = TreeNode(12)
root.left.left = TreeNode(8)
root.left.right = TreeNode(7)
s.helper(root,22)