二叉树问题

题目：判断是都为二叉搜索树。

解法：

有效 二叉搜索树定义如下：

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

二叉搜索树的中序遍历必须为升序的，可以抓住这个突破口，在中序遍历的代码中进行更改。

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    pre = float('-inf')
    def isValidBST(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        # 判断是否是二叉搜索树，左边小于根，右边大于根，中序遍历必须为升序
        # 如果为空，返回是
        if not root: return True
        # 先遍历左子树
        if not self.isValidBST(root.left): return False
        # 当当前节点小于上一个节点，则返回不是
        if root.val <= self.pre: return False
        # 更新pre为当前节点
        self.pre = root.val
        # 遍历右子树
        return self.isValidBST(root.right)
        

题目：给定一棵二叉树，判断它是否是高度平衡的二叉树。(一个二叉树的每个节点的左右俩个子树的高度差的绝对值不超过1)

解法：可以用自底向上递归的做法，对于当前遍历到的节点，先递归地判断它的左右子树是否平衡，再判断当前节点的根节点是否平衡，如果一颗子树是平衡的，则返回其高度，否则返回-1。如果存在其中一个子树不平衡，那整棵树都不平衡。

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def isBalanced(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        def height(root):
            # 如果为空，则返回高度为0
            if not root:
                return 0
            # 先递归左子树，求出它的高度
            leftheight = height(root.left)
            # 再递归右子树，求出它的高度
            rightheight = height(root.right)
            # 比较高度差，如果左右子树的高度差大于1，或者下面已经有不平衡的树了也返回-1
            if leftheight == -1 or rightheight == -1 or abs(leftheight-rightheight) > 1:
                return -1
            else:
            # 高度取左右子树中最大的
                return max(leftheight, rightheight) + 1
        # 判断最后的高度是都为-1
        return height(root) >= 0

题目：给定一个二叉树，找到该二叉树中俩个指定节点的最近公共祖先。

          最近公共祖先：节点从下往上，第一个相遇的点就是最近公共祖先。

解法：情况1：节点p是节点q的最近公共祖先，或者节点q是节点p的最近公共祖先。

           情况2：p和q不互为最近公共祖先，需要俩个节点从下往上找到一个相遇的点则为最近公共祖先。

# 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
        """ 
        # 情况1当往下递归遇到节点了，就会直接返回该节点，而不会继续往下走
        if not root or root==p or root==q: return root
        left = self.lowestCommonAncestor(root.left, p, q)
        right = self.lowestCommonAncestor(root.right, p, q)
        # 当左右都不为空值，就是情况2，左右子树都遇到节点了，这时直接返回该头节点，就是最近公共祖先
        if left and right: return root
        # 当有一棵树为空另一个不为空时，返回不空的那个，都为空就返回空值
        return left if left else right

题目：找出二叉搜索树的后继节点，即中序后继，如果没有就返回空。

解法：

情况1：当节点p有右子树的时候，根据中序遍历，它的后继节点必须是它的右子树中的最左节点。

情况2：当没有右子树的时候，根据二叉搜索树的性质来，二叉搜索树左树小于根节点，右树大于根节点，因为p的后继节点是大于p的，所以当遇到的值大于p时，有可能是后继节点保留其数值，并跳到其左子树继续观察；当遇到小于p时，跳到它的右子树，找比它大的值。

# 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 inorderSuccessor(self, root, p):
        """
        :type root: TreeNode
        :type p: TreeNode
        :rtype: TreeNode
        """
        k = None
        # 当p节点有右子树的时候，右子树的最左节点就是他的后继节点
        if p.right:
            k = p.right
            while k.left:
                k = k.left
            return k
        else:
        # 当p没有右子树的时候，根据二叉搜索树的性质，后继节点必须大于而当前节点
            node = root
            while node:
                # 如果当前节点大于指定节点，有可能是后继节点也有可能在他的左子树
                if node.val > p.val:
                    k = node
                    node = node.left
                # 如果小于，就跳到右子树
                else:
                    node = node.right
            return k