def deserialize(self, data):
"""Decodes your encoded data to tree.
:type data: str
:rtype: TreeNode
"""
# 处理根节点为空的情况
if data == "[]":
return None
# 拆分根节点
data = data[1:-1].split(",")
size = len(data)
root = TreeNode(int(data[0]))
queue = collections.deque([root])
i = 1
while i < size:
node = queue.popleft()
if data[i] != "null":
node.left = TreeNode(int(data[i]))
queue.append(node.left)
if i + 1 < size and data[i + 1] != "null":
node.right = TreeNode(int(data[i + 1]))
queue.append(node.right)
i += 2
return root
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 insert(self, v: int) -> int:
if not self.queue[0].left:
self.queue[0].left = TreeNode(v)
self.queue.append(self.queue[0].left)
return self.queue[0].val
else:
self.queue[0].right = TreeNode(v)
self.queue.append(self.queue[0].right)
return self.queue.popleft().val
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(node):
if val < node.val:
if node.left is None:
node.left = TreeNode(val)
else:
helper(node.left)
if val > node.val:
if node.right is None:
node.right = TreeNode(val)
else:
helper(node.right)
def constructMaximumBinaryTree(self, nums: List[int]) -> TreeNode:
stack = []
for n in nums:
node = TreeNode(n)
while stack and stack[-1].val < n:
node.left = stack.pop()
if stack:
stack[-1].right = node
stack.append(node)
return stack[0]
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 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 increasingBST(self, root: TreeNode) -> TreeNode:
def helper(node):
if node:
yield from helper(node.left)
yield node.val
yield from helper(node.right)
head = node = TreeNode(0)
for val in helper(root):
node.right = TreeNode(val)
node = node.right
return head.right
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 convertBST(self, root: TreeNode) -> TreeNode:
if root:
self.convertBST(root.right)
self.total += root.val
root.val = self.total
self.convertBST(root.left)
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 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 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 printTree(self, root: TreeNode) -> List[List[str]]:
# 生成包含None的层序遍历的结果
lst = []
queue = collections.deque([root])
while True:
now_val = []
have_find = False
for _ in range(len(queue)):
node = queue.popleft()
if node.val != "":
have_find = True
now_val.append(str(node.val))
if node.left:
queue.append(node.left)
else:
queue.append(TreeNode(""))
if node.right:
queue.append(node.right)
else:
queue.append(TreeNode(""))
else:
now_val.append("")
queue.append(TreeNode(""))
queue.append(TreeNode(""))
if not have_find:
break
else:
lst.append(now_val)
# 将结果转换为输出格式
height = len(lst) # 二叉树的高度
length = 2**height - 1 # 输出结果的宽度
ans = []
for i in range(height):
line = [""] * length
for j in range(len(lst[i])):
idx = (2 * (j + 1) - 1) * (2**(height - (i + 1))) - 1
line[idx] = lst[i][j]
ans.append(line)
return ans
def helper(node):
if node.left:
helper(node.left)
new_node = TreeNode(node.val)
if self.root is None:
self.root = self.last = new_node
else:
self.last.right = new_node
self.last = self.last.right
if node.right:
helper(node.right)
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 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 allPossibleFBT(self, N: int) -> List[TreeNode]:
# 处理无法实现满二叉树的情况
if N % 2 == 0:
return []
# 计算需要递归的深度
n = N // 2
# 递归生成所有满足的结果
root = TreeNode(0)
def recursor(leaf_lst, k):
if k == 0:
if (tree_str := str(root)) not in self.already:
self.ans.append(copy.deepcopy(root))
self.already.add(tree_str)
else:
def insertIntoBST(self, root: TreeNode, val: int) -> TreeNode:
def helper(node):
if val < node.val:
if node.left is None:
node.left = TreeNode(val)
else:
helper(node.left)
if val > node.val:
if node.right is None:
node.right = TreeNode(val)
else:
helper(node.right)
if root is None:
return TreeNode(val)
else:
helper(root)
return root
def insertIntoMaxTree(self, root: TreeNode, val: int) -> TreeNode:
# 处理目标值大于根节点的情况
if val > root.val:
new = TreeNode(val)
new.left = root
return new
# 处理目标值小于根节点的情况
last = root
node = root.right
while node and val < node.val:
last = node
node = node.right
new = TreeNode(val)
new.left = node
last.right = new
return root
def __init__(self):
self.memo = {
0: [],
1: [TreeNode(0)]
}
return []
# 计算需要递归的深度
n = N // 2
# 递归生成所有满足的结果
root = TreeNode(0)
def recursor(leaf_lst, k):
if k == 0:
if (tree_str := str(root)) not in self.already:
self.ans.append(copy.deepcopy(root))
self.already.add(tree_str)
else:
for leaf in leaf_lst:
leaf.left = TreeNode(0)
leaf.right = TreeNode(0)
new_leaf_lst = leaf_lst.copy()
new_leaf_lst._remove(leaf)
new_leaf_lst.append(leaf.left)
new_leaf_lst.append(leaf.right)
recursor(new_leaf_lst, k - 1)
leaf.right = None
leaf.left = None
recursor([root], n)
return self.ans
if __name__ == "__main__":
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 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
