leetcode题：98. 验证二叉搜索树（中等）

一、题目描述：98. 验证二叉搜索树（中等）

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

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

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

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

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/validate-binary-search-tree
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

二、解题思路

方法一、递归，每次判断当前节点是否比左子树的最大值小并且当前节点比右子树的小值大。如果否则返回false

方法二、中序遍历整棵树，判断前一个节点是否比后一个节点小。如果否则返回false。

三、代码

方法一、

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
typedef struct maxmin
{
    int min;
    int max;
    maxmin():min(INT_MAX),max(INT_MIN){}
} Maxmin;
class Solution {
public:
    bool isValidBST(TreeNode* root) {
        if(root == NULL)
            return true;
        Maxmin max_min;
        bool check = isValidBST(root,max_min);
        return check;

    }
    bool isValidBST(TreeNode* root,  Maxmin & max_min)
    {
        if(root == NULL)
            return true;
        bool is_valid_left = true;
        bool is_valid_right = true;
        Maxmin max_min_left;
        Maxmin max_min_right;
        if(root->left == NULL && root->right == NULL)
        {
            max_min.min = root->val;
            max_min.max = root->val;
            return true;
        }
        if(root->left != NULL)
        {
            if(root->val <= root->left->val)
                return false;
            is_valid_left = isValidBST(root->left,max_min_left);
        }
        if(root->right != NULL)
        {
            if(root->val >= root->right->val)
                return false;
            is_valid_right = isValidBST(root->right,max_min_right);
        }
        if(max_min_left.max >= root->val && root->left != NULL)
            return false;
        if(max_min_right.min <= root->val && root->right != NULL)
            return false;
        if(!(is_valid_left & is_valid_right))
           return false;
        max_min.max = max(max_min_left.max,max_min_right.max);
        max_min.max = max(max_min.max,root->val);
        max_min.min = min(max_min_left.min,max_min_right.min);
        max_min.min = min(max_min.min,root->val);
        return is_valid_left & is_valid_right;
    }
};

方法一、代码2

class Solution {
  public boolean helper(TreeNode node, Integer lower, Integer upper) {
    if (node == null) return true;

    int val = node.val;
    if (lower != null && val <= lower) return false;
    if (upper != null && val >= upper) return false;

    if (! helper(node.right, val, upper)) return false;
    if (! helper(node.left, lower, val)) return false;
    return true;
  }

  public boolean isValidBST(TreeNode root) {
    return helper(root, null, null);
  }
}

方法二

class Solution {
  public boolean isValidBST(TreeNode root) {
    Stack<TreeNode> stack = new Stack();
    double inorder = - Double.MAX_VALUE;

    while (!stack.isEmpty() || root != null) {
      while (root != null) {
        stack.push(root);
        root = root.left;
      }
      root = stack.pop();
      // If next element in inorder traversal
      // is smaller than the previous one
      // that's not BST.
      if (root.val <= inorder) return false;
      inorder = root.val;
      root = root.right;
    }
    return true;
  }
}