递归构造
每次选取最大值
def constructMaximumBinaryTree(self, nums: List[int]) -> Optional[TreeNode]:
def cut(arr):
if not arr:
return
rootnode = max(arr)
ind = arr.index(rootnode)
root = TreeNode(rootnode)
left = arr[:ind]
right = arr[ind+1:]
root.left = cut(left)
root.right = cut(right)
return root
return cut(nums)
def mergeTrees(self, root1: Optional[TreeNode], root2: Optional[TreeNode]) -> Optional[TreeNode]:
if not root1:
return root2
if not root2:
return root1
# root = TreeNode(root1.val+root2.val)
def combine(root1, root2):
if not root1:
return root2
if not root2:
return root1
node = TreeNode(root1.val+root2.val)
node.left = combine(root1.left, root2.left)
node.right = combine(root1.right, root2.right)
return node
root = combine(root1, root2)
return root
def searchBST(self, root: Optional[TreeNode], val: int) -> Optional[TreeNode]:
def search(root):
if not root:
return
if root.val == val:
return root
node_l = search(root.left)
if node_l:
return node_l
node_r = search(root.right)
if node_r:
return node_r
node = search(root)
return node
利用二叉搜索树的性质
def searchBST(self, root, val):
"""
:type root: TreeNode
:type val: int
:rtype: TreeNode
"""
# children = TreeNode()
# def search(root):
# if not root:
# return root
# print(root.val)
# if root.val == val:
# children = TreeNode(root.val)
# return children
# search(root.left)
# search(root.right)
# children = search(root)
# return children
# 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
# 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
# 它的左、右子树也分别为二叉搜索树
if not root or root.val == val:
return root
if root.val > val:
return self.searchBST(root.left, val)
if root.val < val:
return self.searchBST(root.right, val)
中序遍历【左中右】判断是否有序
def isValidBST(self, root: Optional[TreeNode]) -> bool:
ino = []
root_v = root.val
def inorder(root):
if not root:
return
inorder(root.left)
ino.append(root.val)
inorder(root.right)
inorder(root)
for i in range(1,len(ino)):
if ino[i] - ino[i-1] <= 0:
return False
return True
