《极客时间--算法面试》--二叉树

目录

　　验证二叉搜索树

 　　二叉树的最近公共祖先

　　二叉搜索树的最近公共祖先　　

题目：力扣98题：验证二叉搜索树

https://leetcode-cn.com/problems/validate-binary-search-tree/submissions/

思路：

　　对二叉搜索树有个明确的定义，

　　　　即左子树所有的值小于根节点，右子树所有的值大于根节点的值。

　　一、采用中序遍历，然后进行判断是否升序即可。

　　二、采用递归，找到左子树的最大值，右子树的最小值，如果左子树小于根节点且右子树大于根节点，即为二叉搜索树。

代码一：中序遍历法

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def isValidBST(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        inorder = self.inorder(root)                                          #拿到中序列表
        return inorder == list(sorted(inorder))                               #进行排序后转换成列表，判断是否一致，一致则是二叉搜索树，否则不是二叉搜索树
    def inorder(self,root):                                                   #中序遍历算法
        if root is None:                                                      #根节点为空，直接返回[]
            return []
        return self.inorder(root.left)+[root.val]+self.inorder(root.right)    #返回其列表 

代码二：递归遍历法

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution(object):
    def isValidBST(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        self.prev = None                                #前继节点
        return self.helper(root)                        #开始递归调用
    def helper(self,root):
        if root is None:                                #如果是空子树，即为二叉搜索树
            return True
        if not self.helper(root.left):                  #递归的调用左子树，
            return False
        if self.prev and self.prev.val>=root.val:       #如果前继节点存在并且值大于根节点值，则不是二叉搜索树
            return False
        self.prev = root                                #将根节点赋予前继节点
        return self.helper(root.right)                  #递归调用右子树          

题目：二叉树的最近公共祖先

思路：

　　一、遍历查找两个节点路径，通过对比两个路径是否一致；

　　二、采用递归的思路，分别查找左右子树。

代码：

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def lowestCommonAncestor(self, root, p, q):
        """
        :type root: TreeNode
        :type p: TreeNode
        :type q: TreeNode
        :rtype: TreeNode
        """
        if  root == None or root == p or root == q:         #如果root为空或者为pq就返回pq即为root
            return root
        left = self.lowestCommonAncestor(root.left,p,q)     #分别查找左子树
        right = self.lowestCommonAncestor(root.right,p,q)   #查找右子树
        if left is None:                                    #如果左子树为空，就返回右子树
            return right
        elif right is None:                                 #如果右子树为空，就返回左子树
            return left
        else:
            return root                                     #否则root就是最近的公共祖先

题目：二叉搜索树的最近公共祖先

思路：

　　明确定义二叉搜索树，左子树所有节点小于根节点，右子树所有节点大于根节点。

　　判断两个节点和根节点的值，如果小于则调用左子树，如果大于调用右子树。如果一个大于一个小于就分叉左右子树，那么就是当前根节点的位置了，便直接返回。

代码：

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def lowestCommonAncestor(self, root, p, q):
        """
        :type root: TreeNode
        :type p: TreeNode
        :type q: TreeNode
        :rtype: TreeNode
        """
        if p.val<root.val>q.val:                                #如果pq的值都小于根节点，那么在左子树
            return self.lowestCommonAncestor(root.left,p,q)     #便调用左子树
        if p.val>root.val<q.val:                                #如果pq值都大于根节点，在右子树
            return self.lowestCommonAncestor(root.right,p,q)    #调用右子树
        return root                                             #如果都不是，说明分叉了，那么就是祖先了