def deleteNode(self, root: TreeNode, key: int) -> TreeNode:
if not root:
return None
if key == root.val:
if root.right:
p = root
cur = root.right
while cur.left:
p = cur
cur = cur.left
root.val = cur.val
self.helper(p, cur)
elif root.left:
p = root
cur = root.left
while cur.right:
p = cur
cur = cur.right
root.val = cur.val
self.helper(p, cur)
else:
return None
elif key < root.val:
root.left = self.deleteNode(root.left, key)
else:
root.right = self.deleteNode(root.right, key)
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)
else:
root.left = self.insertIntoBST(root.left, val)
return root
def helper(self, nums, lower, upper):
if not nums or not (lower < nums[0] < upper):
return None
val = nums.popleft()
root = TreeNode(val)
root.left = self.helper(nums, lower, val)
root.right = self.helper(nums, val, upper)
return root
def build(self, vals, b, e):
if b > e:
return None
m = (e - b) // 2 + b
root = TreeNode(vals[m])
root.left = self.build(vals, b, m - 1)
root.right = self.build(vals, m + 1, e)
return root
def invertTree(self, root: TreeNode) -> TreeNode:
if not root:
return root
prevLeft = root.left
root.left = self.invertTree(root.right)
root.right = self.invertTree(prevLeft)
return root
def pruneTree2(self, root: TreeNode) -> TreeNode:
if not root:
return None
root.left = self.pruneTree(root.left)
root.right = self.pruneTree(root.right)
if not root.left and not root.right and not root.val:
return None
return root
def mergeTrees(self, t1: TreeNode, t2: TreeNode) -> TreeNode:
if not t1:
return t2
if not t2:
return t1
root = TreeNode(t1.val + t2.val)
root.left = self.mergeTrees(t1.left, t2.left)
root.right = self.mergeTrees(t1.right, t2.right)
return root
def deserializeHelper(self, nums):
if not nums:
return None
root = TreeNode(nums[0])
i = 1
while i < len(nums) and nums[i] < nums[0]:
i += 1
root.left = self.deserializeHelper(nums[1:i])
root.right = self.deserializeHelper(nums[i:])
return root
def deserialize(self, data):
"""Decodes your encoded data to tree.
:type data: str
:rtype: TreeNode
"""
if not data:
return None
nodes = [
TreeNode(int(x)) if x != 'null' else None for x in data.split()
]
root = nodes[0]
queue = [root]
i = 1
while queue:
cur = queue.pop(0)
if cur:
cur.left = nodes[i]
cur.right = nodes[i + 1]
i += 2
queue.append(cur.left)
queue.append(cur.right)
return root
def insertIntoBST2(self, root: TreeNode, val: int) -> TreeNode:
if not root:
return TreeNode(val)
cur = root
while True:
if val > cur.val:
if not cur.right:
cur.right = TreeNode(val)
break
else:
cur = cur.right
else:
if not cur.left:
cur.left = TreeNode(val)
break
else:
cur = cur.left
return root
def deleteNode(self, root: TreeNode, key: int) -> TreeNode:
if not root:
return None
if key == root.val:
if not root.right:
return root.left
else:
cur = root.right
while cur.left:
cur = cur.left
root.val = cur.val
root.right = self.deleteNode(root.right, cur.val)
elif key < root.val:
root.left = self.deleteNode(root.left, key)
else:
root.right = self.deleteNode(root.right, key)
return root
def addOneRow2(self, root: TreeNode, v: int, d: int) -> TreeNode:
dummy = TreeNode(0)
dummy.left = root
q = [dummy]
for _ in range(d - 1):
q = [y for x in q for y in (x.left, x.right) if y]
for node in q:
nl, nr = TreeNode(v), TreeNode(v)
nl.left = node.left
node.left = nl
nr.right = node.right
node.right = nr
return dummy.left
def addOneRow(self, root: TreeNode, v: int, d: int) -> TreeNode:
if not root:
return None
if d == 1:
res = TreeNode(v)
res.left = root
return res
if d == 2:
nl, nr = TreeNode(v), TreeNode(v)
nl.left = root.left
root.left = nl
nr.right = root.right
root.right = nr
else:
root.left = self.addOneRow(root.left, v, d - 1)
root.right = self.addOneRow(root.right, v, d - 1)
return root