def sortedArrayToBST(self, nums: List[int]) -> TreeNode:
"""
分析了一下，除了 root 可能有 right 其余的都是 left
0
算法不正确，原因在于题目要求的树是 DFS
[-10,-3,0,5,9]
5 是 9 的下一层，如果右侧按顺序，就成了 5 在 9 的上一层
1
分析发现，既然是 DF，相当于两树合并起来
还是不对，理解错题目了，是要求平衡二叉树
"""
if not nums:
return None
mid = len(nums) // 2
root = TreeNode(nums[mid])
left = root
for i in range(mid - 1, -1, -1):
left.left = TreeNode(nums[i])
left = left.left
if len(nums) > 2:
# 右侧树，从最后一个元倒退回去
root.right = TreeNode(nums[-1])
left = root.right
for i in range(len(nums) - 2, mid, -1):
left.left = TreeNode(nums[i])
left = left.left
return root
def insertIntoBST11(self, root: TreeNode, val: int) -> TreeNode:
self.bianli(root)
i = 0
for i in range(len(self.xl)):
if val > self.xl[i].val:
break
if not self.xl[i].right:
self.xl[i].right = TreeNode(val)
return root
if not self.xl[i + 1].left:
self.xl[i + 1].left = TreeNode(val)
return root
def copy(self, source: TreeNode) -> TreeNode:
if not source:
return source
res = TreeNode(source.val)
res.left = self.copy(source.left)
res.right = self.copy(source.right)
return res
def build(self, values, index, n):
if index <= n and index in values:
node = TreeNode(values[index])
node.left = self.build(values, 2 * index + 1, n)
node.right = self.build(values, 2 * index + 2, n)
return node
else:
return None
def insert(self, root: TreeNode, num: int) -> TreeNode:
if not root:
return TreeNode(num)
if num < root.val:
root.left = self.insert(root.left, num)
else:
root.right = self.insert(root.right, num)
return root
def sorted_array_to_bst(nums: list[int]) -> Optional[TreeNode]:
if not nums:
return None
middle = len(nums) // 2
root = TreeNode(nums[middle])
root.left = sorted_array_to_bst(nums[:middle])
root.right = sorted_array_to_bst(nums[middle + 1 :])
return root
def build_tree(preorder: List[int], inorder: List[int]) -> Optional[TreeNode]:
if not inorder:
return None
mid = inorder.index(preorder[0])
root = TreeNode(preorder[0])
if len(inorder) > 1:
root.left = build_tree(preorder[1 : mid + 1], inorder[:mid])
root.right = build_tree(preorder[mid + 1 :], inorder[mid + 1 :])
return root
def sorted_array_to_bst(self, nums, start, stop):
if start <= stop:
# 这里 + 1 保证如果对称的时候，取偏右，因为题目中数组是中序遍历的
mid = start + (stop - start + 1) // 2
node = TreeNode(nums[mid])
node.left = self.sorted_array_to_bst(nums, start, mid - 1)
node.right = self.sorted_array_to_bst(nums, mid + 1, stop)
return node
else:
return None
def build_bst(start: int, end: int) -> Optional[TreeNode]:
nonlocal head
if start > end:
return None
middle = (start + end) // 2
left = build_bst(start, middle - 1)
root = TreeNode(head.val)
root.left = left
head = head.next
root.right = build_bst(middle + 1, end)
return root
def insertIntoBST(self, root: TreeNode, val: int) -> TreeNode:
if not root:
return TreeNode(val)
if val > root.val:
root.right = self.insertIntoBST(root.right, val)
if val < root.val:
root.left = self.insertIntoBST(root.left, val)
return root
def sortedArrayToBST(self, nums: List[int]) -> TreeNode:
"""
分析了一下，除了 root 可能有 right 其余的都是 left
0
算法不正确，原因在于题目要求的树是 DF
[-10,-3,0,5,9]
5 是 9 的下一层，如果右侧按顺序，就成了 5 在 9 的上一层
"""
if not nums:
return None
mid = len(nums) // 2
root = TreeNode(nums[mid])
left = root
for i in range(mid - 1, -1, -1):
left.left = TreeNode(nums[i])
left = left.left
right = root
for i in range(mid + 1, len(nums)):
right.right = TreeNode(nums[i])
right = right.right
return root
def helper(self, ans: dict, pre: TreeNode, nums: List[int]):
if not nums:
tree = self.copy(pre)
node_str = self.node_str(tree)
if node_str not in ans:
ans[node_str] = tree
else:
for i, num in enumerate(nums):
nums.remove(num)
if pre is None:
self.helper(ans, TreeNode(num), nums)
else:
if self.insert(pre, num): # 成功插入才继续
self.helper(ans, pre, nums)
self.delete(pre, num)
nums.insert(i, num)
def helper(in_order: List[int],
post_order: List[int]) -> Optional[TreeNode]:
if in_order and post_order:
root_val = post_order[-1]
for root_offset, val in enumerate(in_order):
if val == root_val:
break
else:
root_offset = 0
root = TreeNode(root_val)
root.left = helper(in_order[:root_offset],
post_order[:root_offset])
root.right = helper(in_order[root_offset + 1:],
post_order[root_offset:-1])
return root
def sortedArrayToBST(self, nums: List[int]) -> TreeNode:
"""
分析了一下，除了 root 可能有 right 其余的都是 left
0
算法不正确，原因在于题目要求的树是 DFS
[-10,-3,0,5,9]
5 是 9 的下一层，如果右侧按顺序，就成了 5 在 9 的上一层
1
分析发现，既然是 DF，相当于两树合并起来
还是不对，理解错题目了，是要求平衡二叉树
2
感觉可以用索引来完成
分析时间复杂度
取切片时称动元素为基本操作
1/2 n
1/4 n
1/8 n
1/8 n
1/4 n
1/8 n
1/8 n
1/2 n
...
可以看到每一轮共有 k 个 1/k n
所以每一轮为 n
而轮数为 log(n) 所以 T(n)=O(n logn)
分析空间复杂度
输出的树不考虑，那临时占用的就只有 mid 变量，与结点数一致
S(n)=O(n)
"""
if not nums:
return None
mid = len(nums) // 2
root = TreeNode(nums[mid])
# 原数组中序遍历而来，所以左右各能组成树
if 0 < mid:
root.left = self.sortedArrayToBST(nums[:mid])
if mid + 1 < len(nums):
root.right = self.sortedArrayToBST(nums[mid + 1:])
return root
def insert_into_bst(root: TreeNode, val: int) -> TreeNode:
node, prev, is_left = root, None, False
while node:
prev = node
if val < node.val:
node, is_left = node.left, True
else:
node, is_left = node.right, False
new_node = TreeNode(val)
if prev is None:
return new_node
if is_left:
prev.left = new_node
else:
prev.right = new_node
return root
def deserialize(data: str) -> Optional[TreeNode]:
nodes = map(lambda t: None if t in ("null", "") else TreeNode(int(t)),
data.split(","))
root = next(nodes)
if root is None:
return None
queue = deque([root])
is_left = True
node = None
for next_node in nodes:
if next_node:
queue.append(next_node)
if is_left:
node = queue.popleft()
node.left = next_node
else:
node.right = next_node
is_left = not is_left
return root
def recover_tree(root: TreeNode) -> None:
if not root:
return
prev = TreeNode(-(2 ** 31) - 1)
first_error, second_error = None, None
def inorder(node: TreeNode) -> None:
nonlocal prev, first_error, second_error
if node.left:
inorder(node.left)
if prev.val >= node.val and not first_error:
first_error = prev
if prev.val >= node.val and first_error:
second_error = node
prev = node
if node.right:
inorder(node.right)
inorder(root)
first_error.val, second_error.val = second_error.val, first_error.val