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