leetcode 98. Validate Binary Search Tree DFS深度优先搜索 + 两个递归函数 + 一个错误做法

Given a binary tree, determine if it is a valid binary search tree (BST).

Assume a BST is defined as follows:

The left subtree of a node contains only nodes with keys less than the node’s key.
The right subtree of a node contains only nodes with keys greater than the node’s key.
Both the left and right subtrees must also be binary search trees.
Example 1:
2
/ \
1 3
Binary tree [2,1,3], return true.
Example 2:
1
/ \
2 3
Binary tree [1,2,3], return false.

题意就是判断是否是一个合理的二叉搜索树BST，注意判断二叉搜索树肯定要递归处理，左子结点要比父结点小，右子结点要比父结点大，同时所有的左子结点要比父结点小，所有的右子结点要比父结点大， 我写了一个错误的递归做法，值得反思和借鉴。

代码如下：

/*class TreeNode
 {
     int val;
     TreeNode left;
     TreeNode right;
     TreeNode(int x) { val = x; }
 }*/

/*
 * 判断二叉搜索树肯定要递归处理，
 * 左子结点要比父结点小，右子结点要比父结点大，
 * 同时所有的左子结点要比父结点小，所有的右子结点要比父结点大，
 * 
 * 我写了一个错误的递归做法，值得反思和借鉴
 * */
public class Solution 
{
    public boolean isValidBST(TreeNode root) 
    {
        return isVaild(root);
    }

    boolean isVaild(TreeNode root) 
    {
        if(root==null)
            return true;
        else
        {
            if(byDFSLeft(root.left,root.val) && byDFSRight(root.right,root.val))
                return isVaild(root.left) && isVaild(root.right);
            else
                return false;
        }
    }

    //用于判断左子树的所有节点的val要比根节点的val要小
    boolean byDFSLeft(TreeNode left, int val)
    {
        if(left==null)
            return true;
        else if(left.val >= val)
            return false;
        else
            return byDFSLeft(left.left, val) && byDFSLeft(left.right, val);
    }

     //用于判断右子树的所有节点的val要比根节点的val要大
    boolean byDFSRight(TreeNode right, int val) 
    {
        if(right==null)
            return true;
        else if(right.val <= val)
            return false;
        else
            return byDFSRight(right.left, val) && byDFSRight(right.right, val);
    }

    /*
     * 这是一个看似正确其实错误的解法，因为忽略了一个性质：左子树的所有结点的val都要
     * 比根节点的root的val小，右子树的所有结点的val都要比根节点root的val大
     * */
    boolean isVaildWrong(TreeNode root) 
    {
        if(root==null)
            return true;
        else
        {
            if(root.left!=null && root.left.val>=root.val)
                return false;
            if(root.right!=null && root.right.val<=root.val)
                return false;           
            return isVaild(root.left) && isVaild(root.right);
        }   
    }
}

下面是C++的做法，这道题肯定是用DFS深度优先搜索来做，但是一个直接的想法可能是错误的，正如上面的Java的做法，所以还是需要好好想一下

代码如下：

#include<iostream>
#include <vector>

using namespace std;

/*
struct TreeNode
{
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};
*/

class Solution 
{
public:
    bool isValidBST(TreeNode* root) 
    {
        if (root == NULL)
            return true;
        else
        {
            if (isVaildLeft(root->left, root->val) && isVaildRight(root->right, root->val))
                return isValidBST(root->left) && isValidBST(root->right);
            else
                return false;
        }
    }

    bool isVaildLeft(TreeNode* root, int target)
    {
        if (root == NULL)
            return true;
        else if (root->val >= target)
            return false;
        else
            return isVaildLeft(root->left, target) && isVaildLeft(root->right, target);
    }

    bool isVaildRight(TreeNode* root, int target)
    {
        if (root == NULL)
            return true;
        else if (root->val <= target)
            return false;
        else
            return isVaildRight(root->left, target) && isVaildRight(root->right, target);
    }
};