def get_node(a, b):
if a > b:
return None
t = (a + b) // 2
node = TreeNode(nums[t])
node.left = get_node(a, t - 1)
node.right = get_node(t + 1, b)
return node
def insertIntoBST(self, root: TreeNode, val: int) -> TreeNode:
if not root:
return TreeNode(val)
if val < root.val:
root.left = self.insertIntoBST(root.left, val)
else:
root.right = self.insertIntoBST(root.right, val)
return root
def bstFromPreorder(self, preorder: List[int]) -> TreeNode:
if preorder:
root = TreeNode(preorder[0])
i = 1
while i < len(preorder) and preorder[i] < preorder[0]:
i += 1
root.left = self.bstFromPreorder(preorder[1:i])
root.right = self.bstFromPreorder(preorder[i:])
return root
def constructMaximumBinaryTree(self, nums: List[int]) -> TreeNode:
if nums:
max_idx, max_val = -1, float("-inf")
for i, n in enumerate(nums):
if n > max_val:
max_val = n
max_idx = i
root = TreeNode(max_val)
root.left = self.constructMaximumBinaryTree(nums[:max_idx])
root.right = self.constructMaximumBinaryTree(nums[max_idx + 1:])
return root
def build_tree(sub_lst, level=0):
if sub_lst:
sign = "-" * (level + 1)
root = TreeNode(sub_lst[0])
if sign in sub_lst[2:]:
idx = sub_lst[2:].index(sign) + 2
root.left = build_tree(sub_lst[2:idx], level + 1)
root.right = build_tree(sub_lst[idx + 1:], level + 1)
else:
root.left = build_tree(sub_lst[2:], level + 1)
return root
def helper(node1, node2):
if node1 and node2:
node = TreeNode(node1.val + node2.val)
node.left = helper(node1.left, node2.left)
node.right = helper(node1.right, node2.right)
return node
elif node1:
return node1
elif node2:
return node2
else:
return None
def helper(vals):
# 边界处理
if len(vals) == 0:
return None
if len(vals) == 1:
return TreeNode(vals[0])
# 二分处理
mid = len(vals) // 2
tree = TreeNode(vals[mid])
tree.left = helper(vals[:mid])
tree.right = helper(vals[mid + 1:])
return tree
def constructFromPrePost(self, pre: List[int],
post: List[int]) -> TreeNode:
if pre:
root = TreeNode(pre[0])
if len(pre) == 1:
return root
idx = post.index(pre[1]) + 1 # 左子树节点数量
root.left = self.constructFromPrePost(pre[1:idx + 1], post[:idx])
root.right = self.constructFromPrePost(pre[idx + 1:], post[idx:-1])
return root
def helper(start, end):
nonlocal head
# 边界处理
if start > end:
return None
# 递归处理
mid = (end + start) // 2
left = helper(start, mid - 1) # 处理左半部分
tree = TreeNode(head.val) # 取出当前树的值（链表刚好遍历的这个位置）
tree.left = left
head = head.next
tree.right = helper(mid + 1, end) # 处理右半部分
return tree
def allPossibleFBT(self, N: int) -> List[TreeNode]:
if N % 2 == 0:
return []
if N not in self.memo:
ans = []
for left in range(1, N, 2):
right = N - left - 1
for left_tree in self.allPossibleFBT(left):
for right_tree in self.allPossibleFBT(right):
root = TreeNode(0)
root.left = left_tree
root.right = right_tree
ans.append(root)
self.memo[N] = ans
return self.memo[N]
def recursor(i_left, i_right, p_left, p_right):
if i_left < i_right and p_left < p_right:
# 寻找当前二叉树的根节点
val = postorder[p_right - 1]
root = TreeNode(val)
# 寻找中序遍历中的根节点位置
idx = inorder.index(val) - i_left
# 处理左子树
root.left = recursor(i_left, i_left + idx, p_left, p_left + idx)
# 处理右子树
root.right = recursor(i_left + idx + 1, i_right, p_left + idx, p_right - 1)
# 返回当前树的结果
return root
def buildTree(self, inorder: List[int], postorder: List[int]) -> TreeNode:
if postorder and inorder:
# 寻找当前二叉树的根节点
val = postorder[-1]
root = TreeNode(val)
# 寻找中序遍历中的根节点位置
idx = inorder.index(val)
# 处理左子树
root.left = self.buildTree(inorder[:idx], postorder[:idx])
# 处理右子树
root.right = self.buildTree(inorder[idx + 1:], postorder[idx:-1])
# 返回当前树的结果
return root
def sortedListToBST(self, head: ListNode) -> TreeNode:
# 边界处理
if not head:
return None
if not head.next:
return TreeNode(head.val)
# 二分处理
slow = head
fast = head.next.next
while fast and fast.next:
slow = slow.next
fast = fast.next.next
tree = TreeNode(slow.next.val)
tree.right = self.sortedListToBST(slow.next.next)
slow.next = None
tree.left = self.sortedListToBST(head)
return tree
def recursor(start, end):
# 处理没有根节点的情况
if start > end:
return [None]
# 处理只剩一个根节点的情况
elif start == end:
return [TreeNode(start)]
# 处理还有多种根节点的情况
ans = []
for i in range(start, end + 1):
left_trees = recursor(start, i - 1)
right_trees = recursor(i + 1, end)
for left_tree in left_trees:
for right_tree in right_trees:
node = TreeNode(i)
node.left = left_tree
node.right = right_tree
ans.append(node)
return ans
def addOneRow(self, root: TreeNode, v: int, d: int) -> TreeNode:
# 处理d的值为1的情况
if d == 1:
ans = TreeNode(v)
ans.left = root
return ans
d -= 1
# 层序遍历树到目标行的上一行
queue = collections.deque([root])
while d > 1:
for _ in range(len(queue)):
node = queue.popleft()
if node.left:
queue.append(node.left)
if node.right:
queue.append(node.right)
d -= 1
print(queue)
# 增加新的一行
for node in queue:
if node.left:
new_node = TreeNode(v)
new_node.left = node.left
node.left = new_node
else:
node.left = TreeNode(v)
if node.right:
new_node = TreeNode(v)
new_node.right = node.right
node.right = new_node
else:
node.right = TreeNode(v)
return root
def sortedArrayToBST(self,
nums: List[int],
left=None,
right=None) -> TreeNode:
if left is None:
left = 0
if right is None:
right = len(nums) - 1
# 处理只有一个节点的情况
if left > right:
return None
elif left == right:
return TreeNode(nums[left])
# 处理有更多节点的情况
else:
mid = (left + right) // 2
head = TreeNode(nums[mid])
head.left = self.sortedArrayToBST(nums, left=left, right=mid - 1)
head.right = self.sortedArrayToBST(nums, left=mid + 1, right=right)
return head
def pruneTree(self, root: TreeNode) -> TreeNode:
if root:
root.left = self.pruneTree(root.left)
root.right = self.pruneTree(root.right)
if root.val == 1 or root.left or root.right:
return root
