669.修剪二叉搜索树
递归
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution:
def trimBST(self, root: Optional[TreeNode], low: int, high: int) -> Optional[TreeNode]:
#递归法
if root is None:
return None
if root.val<low:
#寻找符合区间的节点
return self.trimBST(root.right,low,high)
if root.val>high:
return self.trimBST(root.left,low,high)
root.left=self.trimBST(root.left,low,high)#root.left接入符合条件的左孩子
root.right=self.trimBST(root.right,low,high)
return root
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution:
def trimBST(self, root: Optional[TreeNode], L: int, R: int) -> Optional[TreeNode]:
#迭代法
if not root:
return None
while root and (root.val<L or root.val>R):
if root.val <L:
root=root.right#小于L往右走
else:
root=root.left#大于R往左走
cur=root
while cur:#处理左孩子元素小于L的情况
while cur.left and cur.left.val<L:
cur.left=cur.left.right
cur=cur.left
cur=root
while cur:
while cur.right and cur.right.val>R:
cur.right=cur.right.left
cur=cur.right
return root
108.将有序数组转换为二叉搜索树
本质就是寻找分割点,分割点作为当前节点,然后递归左区间和右区间
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution:
def sortedArrayToBST(self, nums: List[int]) -> Optional[TreeNode]:
#迭代法
root=self.traversal(nums,0,len(nums)-1)
return root
def traversal(self,nums,left,right):
if left>right:
return None
mid=left+(right-left)//2#防止溢出
root=TreeNode(nums[mid])
root.left=self.traversal(nums,left,mid-1)
root.right=self.traversal(nums,mid+1,right)
return root
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution:
def sortedArrayToBST(self, nums: List[int]) -> Optional[TreeNode]:
if len(nums)==0:
return None
root=TreeNode(0)#初始根jiedian
nodeQue=deque()#放遍历的节点
leftQue=deque()#存放左区间下标
rightQue=deque()
nodeQue.append(root)
leftQue.append(0)#0为左区间下标初始位置
rightQue.append(len(nums)-1)
while nodeQue:
curNode=nodeQue.popleft()
left=leftQue.popleft()
right=rightQue.popleft()
mid=left+(right-left)//2
curNode.val=nums[mid]
if left<=mid-1:
curNode.left=TreeNode(0)
nodeQue.append(curNode.left)
leftQue.append(left)
rightQue.append(mid-1)
if right>=mid+1:
curNode.right=TreeNode(0)
nodeQue.append(curNode.right)
leftQue.append(mid+1)
rightQue.append(right)
return root
538.把二叉搜索树转换为累加树
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution:
def convertBST(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
self.pre=0
self.traversal(root)
return root
def traversal(self,cur):
if cur is None:
return
self.traversal(cur.right)
cur.val+=self.pre
self.pre=cur.val
self.traversal(cur.left)
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution:
def convertBST(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
if not root:
return root
stack=[]
result=[]
cur=root
pre=0
while cur or stack:
if cur:
stack.append(cur)
cur=cur.right
else:
cur=stack.pop()
cur.val+=pre
pre=cur.val
cur=cur.left
retrun root