树理论与二叉树习题：验证二叉树、二叉树（二叉搜索树）最近公共祖先

树，二叉树，二叉搜索树

链表：每个next指向后续节点

当要访问中间的节点时，要从头或双向链表从尾部去找。

所以当一个节点有多个next，比如left与right，child1、child2…就形成了树。树是无环单向链接的。

二叉树：一个节点最多只有两个子节点。

如果孩子节点再指向回去，则是图。

Python：实现二叉树

class TreeNode:
    def __init__(self,val):
        self.val = val
        self.left,self.right = None,None

二叉树的遍历:

• 前序：根左右
• 中序：左根右
• 后序：左右根

（btw：在实际的使用中用的很少，常用的都是深度优先遍历与广度优先遍历）

    #前序遍历代码，另外两种同理。
    def preorder(self,root):
        if root:
            #访问根节点
            self.traverse_path.append(root.val)
            self.preorder(root.left)
            self.preorder(root.right)

二叉搜索树（有序二叉树）

是指一棵空树，或者具有以下性质的树:

1. 左子树上所有的节点的值均小于它的根节点的值。
2. 右子树上所有的节点的值均大于它的根节点的值
3. 递归的，左、右子树也分别为二叉搜索树

二叉搜索树如果只有一边的子树，则查询的时间是最差O（n）,平均为O(log(n))。如果出现最差可以使用二叉平衡树来重新建树。

98.验证二叉搜索树

来源链接：https://leetcode-cn.com/problems/validate-binary-search-tree

给定一个二叉树，判断其是否是一个有效的二叉搜索树。

假设一个二叉搜索树具有如下特征：

节点的左子树只包含小于当前节点的数。
节点的右子树只包含大于当前节点的数。
所有左子树和右子树自身必须也是二叉搜索树。

示例:

输入:
    2
   / \
  1   3
输出: true

输入:
    5
   / \
  1   4
     / \
    3   6
输出: false
解释: 输入为: [5,1,4,null,null,3,6]。
     根节点的值为 5 ，但是其右子节点值为 4 。

思路1：根据二叉搜索树的特点可知，二叉搜索树的中序遍历是升序的，且没有重复的值。所以可以写出树中序遍历的结果，查看他是否是无重复且升序排列的。时间复杂度O(n)

# 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
        """
        global res
        res =[]
        self.inOrder(root)
        #要去重，因为二叉搜索树是不可能有重复节点的
        #不去重的话，[1,1]树结果是错误的
        return res == sorted(set(res))

    def inOrder(self,node):
        if node:
            self.inOrder(node.left)
            res.append(node.val)
            self.inOrder(node.right)

优化思路：

不用存储所有的遍历结果，只用记录前驱节点。即当前驱节点比当前节点小就更新前驱节点继续遍历直到结束，否则返回false。

思路2：递归实现

根据搜索二叉树的性质，左子树上的节点值都不会大于根节点，右子树上的值都不会小根节点的值。

class Solution(object):
    def isValidBST(self,root):
        #float('-inf')一个很小的值
        def helper(root,min=float('-inf'),max=float('inf')):
            if not root:
                return True
            if root.val <= min or root.val >= max:
                return False
            if not helper(root.left,min,root.val):
                return False
            if not helper(root.right,root.val,max):
                return False
            return True
        
        return helper(root)

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

链接：https://leetcode-cn.com/problems/lowest-common-ancestor-of-a-binary-search-tree

题目：

给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。

百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”

例如，给定如下二叉搜索树: root = [6,2,8,0,4,7,9,null,null,3,5]

示例1：

输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8
输出: 6 
解释: 节点 2 和节点 8 的最近公共祖先是 6。

思路：

根据二叉搜索树的性质，可以将p与q与根节点的值v比较：

• p<v<q：表示p,q分别在根的两边，所以最近的公共祖先就是v
• p<q<v：p,q在v的左子树，继续将v.left与p,q比较
• v<p<q：p,q在v的右子树，继续将v.right与p,q比较

这里应该是要使用递归的。

class Solution(object):
    def lowestCommonAncestor(self, root, p, q):
        """
        :type root: TreeNode
        :type p: TreeNode
        :type q: TreeNode
        :rtype: TreeNode
        """

        if root.val>max(p.val,q.val) :
            return self.lowestCommonAncestor(root.left,p,q)
        if root.val<min(p.val,q.val):
            return self.lowestCommonAncestor(root.right,p,q)
        else:
            return root

非递归的方式：

class Solution(object):
    def lowestCommonAncestor(self, root, p, q):
        """
        :type root: TreeNode
        :type p: TreeNode
        :type q: TreeNode
        :rtype: TreeNode
        """
        while root:
            if root.val<min(p.val,q.val):
                root = root.right
            elif root.val>max(p.val,q.val):
                root = root.left
            else:
                return root

236.二叉树的最近公共祖先（中等）

链接：https://leetcode-cn.com/problems/lowest-common-ancestor-of-a-binary-tree

给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。

百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”

例如，给定如下二叉树: root = [3,5,1,6,2,0,8,null,null,7,4]

思路1：普通二叉树没有搜索二叉树的性质。所以上一个方法不能直接使用。所以可以使用路径寻找法。利用父亲指针，但此题没有父亲节点，不适用。只能从根节点遍历到p/q,路径就代表p/q的父节点们。然后找最后一个公共节点。比较麻烦，不附代码。

思路2：利用辅助函数_findPorQ(root,p,q)递归

• 从根节点开始寻找，如果根是None,p,q中一个则返回根节点即为公共节点。
• 同时将root.left与root.right作为根节点在左右两个子树中寻找left与right。
• 最后判断left与right：一般三种情况left与right都找到了则返回root即可。只找到left则返回left，否则返回None,只找到right则返回right，否则返回None。

    def lowestCommonAncestor(self, root, p, q):
        """
        :type root: TreeNode
        :type p: TreeNode
        :type q: TreeNode
        :rtype: TreeNode
        """
        #root == None 是在找不到的时候返回空即可
        if root == None or root == p or root == q:
            return root
        left = self.lowestCommonAncestor(root.left,p,q)
        right = self.lowestCommonAncestor(root.right,p,q)
        
		#这个判断需要好好理一下
        if left != None:
            if right != None:
                return root
            return left
        elif right != None:
            return right
        return None

tips：**二叉树的主要考点——递归。**不但要可以口头表达思想，还要能够用代码实现。实现之后才是真的理解。