654.最大二叉树
构造树一般采用的是前序遍历,因为先构造中间节点,然后递归构造左子树和右子树。
跟 二叉树:构造二叉树登场!思路一样
# 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 constructMaximumBinaryTree(self, nums: List[int]) -> Optional[TreeNode]:
if not nums:
return None
#根节点
root_val = max(nums)
root = TreeNode(root_val)
#分割值
sep_id = nums.index(root_val)
#左右子树
left = nums[:sep_id]
right = nums[sep_id+1:]
#递归
root.left = self.constructMaximumBinaryTree(left)
root.right = self.constructMaximumBinaryTree(right)
return root
617.合并二叉树
题目链接/文章讲解:代码随想录
if not root1 and not root2:
return None
最开始终止条件写成了这个是错的,一定要想好终止条件怎么写
正确代码如下:
# 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 mergeTrees(self, root1: Optional[TreeNode], root2: Optional[TreeNode]) -> Optional[TreeNode]:
#终止条件
#但凡有一个节点为空, 就立刻返回另外一个. 如果另外一个也为None就直接返回None.
if not root1:
return root2
if not root2:
return root1
#上面的递归终止条件保证了代码执行到这里root1, root2都非空.
#中
root_val = root1.val + root2.val
root = TreeNode(root_val)
#左
root.left = self.mergeTrees(root1.left,root2.left)
#右
root.right = self.mergeTrees(root1.right,root2.right)
return root
700.二叉搜索树中的搜索
题目链接/文章讲解: 代码随想录
二叉搜索树是一个有序树:
- 若它的左子树不空,则左子树上所有结点的值均小于它的根结点的值;
- 若它的右子树不空,则右子树上所有结点的值均大于它的根结点的值;
- 它的左、右子树也分别为二叉搜索树
这就决定了,二叉搜索树,递归遍历和迭代遍历和普通二叉树都不一样。
(终止条件还是会写错)
# 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 searchBST(self, root: Optional[TreeNode], val: int) -> Optional[TreeNode]:
if not root or val == root.val:
return root
result = None
if val<root.val:
result = self.searchBST(root.left,val)
return result
if val>root.val:
result = self.searchBST(root.right,val)
return result
return result
递归函数还有返回值,所以用一个变量将其接住,所以要 result = searchBST(root.left, val)
迭代法:
因为二叉搜索树的特殊性,也就是节点的有序性,可以不使用辅助栈或者队列就可以写出迭代法。
对于一般二叉树,递归过程中还有回溯的过程,例如走一个左方向的分支走到头了,那么要调头,在走右分支。
而对于二叉搜索树,不需要回溯的过程,因为节点的有序性就帮我们确定了搜索的方向。
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution:
def searchBST(self, root: Optional[TreeNode], val: int) -> Optional[TreeNode]:
while root != None:
if val<root.val:
root = root.left
elif val>root.val:
root = root.right
else:
return root
return None
98.验证二叉搜索树
题目链接/文章讲解:代码随想录
要知道中序遍历下,输出的二叉搜索树节点的数值是有序序列。
有了这个特性,验证二叉搜索树,就相当于变成了判断一个序列是不是递增的了。
递归法(版本一)利用中序递增性质,转换成数组:
# 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 __init__(self):
self.vec = []
def traversal(self,root):
if not root:
return
self.traversal(root.left)
self.vec.append(root.val)
self.traversal(root.right)
def isValidBST(self, root: Optional[TreeNode]) -> bool:
self.traversal(root)
for i in range(1,len(self.vec)):
if self.vec[i-1]>=self.vec[i]:
return False
return True
递归法(版本二)设定极小值,进行比较
# 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 __init__(self):
self.maxval = float('-inf')
def isValidBST(self, root: Optional[TreeNode]) -> bool:
if not root:
return True
left = self.isValidBST(root.left)
if root.val>self.maxval:
self.maxval = root.val
else:
return False
right = self.isValidBST(root.right)
return left and right
递归法(版本三)直接取该树的最小值
# 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 __init__(self):
self.pre = None
def isValidBST(self, root: Optional[TreeNode]) -> bool:
if not root:
return True
left = self.isValidBST(root.left)
if self.pre != None and self.pre>=root.val:
return False
self.pre = root.val # 记录前一个节点
right = self.isValidBST(root.right)
return left and right