数据结构极客视频3

二叉树&&二叉搜索树

对于二叉搜索树 所有的左子树都是小于根节点的 所有的右子树都是大于根节点的

题目：判断是否是二叉搜索树 leetcode98题

思路1 先中序遍历 看是否 是升序 将搜索二叉树中序遍历后是从小到大排序的 定义个函数 得到二叉树的中序 返回list 然后和排序后的list做对比

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

class Solution:
    def isValidBST(self, root: 'TreeNode') -> 'bool':
        inorder=self.inorder(root)
        return inorder==list(sorted(set(inorder)))
    def inorder(self,root:'TreeNode'):
        if root is None :
            return []
        return self.inorder(root.left)+[root.val]+self.inorder(root.right)

思路1.5 考虑中序遍历特点 在思路1的代码中 使用了sort等 比较耗时 改进如下：搜索二叉树中右边的最大 左边的最小 先判断左边的没问题后 使用个pre保存前一个root 进入右边的那个 然后右边的成为新的root

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

class Solution:
    def isValidBST(self, root: 'TreeNode') -> 'bool':
        self.pre=None
        return self.help(root)
    def help(self,root:"TreeNode"):
        if root==None:
            return True
        if not self.help(root.left):
            return False
        if self.pre and self.pre.val>=root.val:
            return False
        self.pre=root
        return self.help(root.right)

思路2 递归法 该方法报错 当数组中存在整型的最大或者最小的时候 不能通过
定义了一个新的函数 存放最大最小 对于左子树 root.val就是最大值 同理右子树

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public boolean isValidBST(TreeNode root) {
                
       
        return valid(root,Integer.MIN_VALUE,Integer.MAX_VALUE);
    }
    public boolean valid(TreeNode root,Integer min,Integer max){        
       if(root==null) return true;
        if(min!=null && min>=root.val) return false;
        if(max!=null && max<=root.val) return false;
        return  valid(root.left,min,root.val)&& valid(root.right,root.val,max);
    }
}

题目 找到第一个公共祖先

思路 1.每个节点向上走 第一个相交点就是了 或者从根节点向下走 但是该方法实现难
2.题目中P与Q 不等 而且是肯定存在 使用递归的思想 左边找一下 右边找一下 如果左边空 那么一定在右边 反之亦然 否则此时就是

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

class Solution:
    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
        return self.findPorQ(root,p,q)
    def findPorQ(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode'):
        if (root==p or root==q or root==None):
            return root
        left = self.findPorQ(root.left,p,q)
        right =self.findPorQ(root.right,p,q)
        if left==None:
            return right
        if right==None:
            return left
        return root
        

如果是二叉搜索树 考虑到二叉搜索树的性质 编码如果

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

class Solution:
    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
        while(root):
            if p.val<root.val>q.val:
                root=root.left
            elif q.val>root.val<p.val:
                root=root.right
            else:
                return root