leetcode_[python/C++]_98_Validate Binary Search Tree

题目链接

【题目】

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.

【解析】

题意：判断一个二叉树是否为二分查找树。

何为二分查找树？1) 左子树的值都比根节点小；2) 右子树的值都比根节点大；3) 左右子树也必须满足上面两个条件。

C++

（1）中序遍历，暴力递归（AC）【慢】

class Solution {
public:
bool isValidBST(TreeNode* root) {
if(root == NULL) return true;
if(!valid_left(root->left, root->val)||!valid_right(root->right,root->val)) return false;
return (isValidBST(root->left) && isValidBST(root->right));
}
bool valid_left(TreeNode* root, int value){
if(root == NULL ) return true;
if(root->val >= value) return false;
return valid_left(root->left,value)&&valid_left(root->right,value);
}
bool valid_right(TreeNode* root, int value){
if(root == NULL ) return true;
if(root->val <= value) return false;
return valid_right(root->left,value)&&valid_right(root->right,value);
}

};

（2）最大最小值比较，递归（Not AC）网上有人说以前是可以AC的

class Solution {
public:
bool isValidBST(TreeNode* root) {
return min_max_judge(root,INT_MIN,INT_MAX);
}
bool min_max_judge(TreeNode* root,int min_value, int max_value){
if(root == NULL) return true;
if(root->val < max_value && root->val > min_value && (min_max_judge(root->left,min_value,root->val) && min_max_judge(root->right,root->val, max_value)))
return true;
else
return false;
}

}

（3）通过vector存中序遍历的val，然后从头到尾判断是否满足递增

因为中序遍历所经过的点的值必然是从小到大的（AC）【较快】

class Solution {
public:
vector<int> oder_vector;
bool isValidBST(TreeNode* root) {
if(root==NULL) return true;
if(root->left==NULL&&root->right==NULL) return true;
oder_search(root,oder_vector);
for(int i=1;i<oder_vector.size();i++)
if(oder_vector[i] <= oder_vector[i-1]) return false;
return true;
}
void oder_search(TreeNode* root,vector<int>& oder_vector){
if(root==NULL) return;
oder_search(root->left,oder_vector);
oder_vector.push_back(root->val);
oder_search(root->right,oder_vector);
}

};

（4）优化（3），改成一种空间复杂度为O（1）的方法（AC）【很快】

每次用pre记录上一个遍历的点，然后比较当前点的val与pre的大小，一旦出现root->val <= pre时候立马退出，快了很多

这里要注意的点就是，如果单纯初始pre=INT_MIN的话，我们并不知道整棵树最左边的点是否比INT_MIN大，万一刚好等于INT_MIN呢就出错了，检测了一下发现，leetcode上面的样例真的有最左边为INT_MIN的，666

所以加了一个判断flag1 = true，第一次过后就变成false,使得pre变成整棵树最左边的值

class Solution {
public:
bool isValidBST(TreeNode* root) {
if(root==NULL) return true;
if(root->left==NULL&&root->right==NULL) return true;
int flag = 0;
bool flag1 = true;
int pre = INT_MIN;
oder_search(root,flag,pre,flag1);
if(flag == 1) return false;
return true;
}
void oder_search(TreeNode* root,int & flag,int& pre,bool& flag1){
if(root==NULL) return;
oder_search(root->left,flag,pre,flag1);
if(flag1)
{
pre = root->val;
flag1 = false;
}
else
{
if(root->val <= pre){
flag = 1;
return;
}
pre = root->val;
}

oder_search(root->right,flag,pre,flag1);
}

};

python

（1）最大最小值：

python是可以AC的，【慢】

注意

-2**31要减1

2**31不能减1

其实就是为了防止inf的问题啦，你可以试试去掉时通不过的样例

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
def isValidBST(self, root):
return self.min_max_search(root,-2**31-1,2**31)#注意测试样例
def min_max_search(self, root, min, max):
if root is None:
return True
return root.val < max and root.val > min and self.min_max_search(root.left,min,root.val) and self.min_max_search(root.right,root.val,max)

（2）C++方法（4）的python版本啦，一股气写的，有点粗糙（AC）

class Solution(object):

def oder_search(self,root,flags,pres,flag1s):
global flag
global flag1
global pre
flag = flags
flag1 = flag1s
pre = pres
if root is None:
return
self.oder_search(root.left,flag,pre,flag1)
if(flag1):
pre = root.val
flag1 = False
else:
if root.val <= pre:
flag = 1
return
pre = root.val
self.oder_search(root.right,flag,pre,flag1)

def isValidBST(self, root):
global flag
global flag1
global pre
if root is None:
return True
if root.left == None and root.right == None:
return True
flag = 0
pre = 0
flag1 = True
self.oder_search(root,flag,pre,flag1)
if flag is 1:
return False
return True

"""
:type root: TreeNode
:rtype: bool
"""

（3）当然，仔细想想可以将（2）的代码精简一下（AC）：

class Solution(object):
value = None
def isValidBST(self, root):
if root is None:
return True
ans = self.isValidBST(root.left)
if(self.value is None):
self.value = root.val
else:
if root.val <= self.value:
ans = False
self.value = root.val
ans = ans and self.isValidBST(root.right)
return ans

然后才发现，精简后并不是立马退出，尴尬，哈哈