Result isBSTHelper(TreeNode* root)
{
if (NULL == root)
{
return Result(true, 0, 0);
}
Result leftR = isBSTHelper(root->left);
Result rightR = isBSTHelper(root->right);
if (leftR.isBST && rightR.isBST &&
(NULL == root->left || leftR.maxV < root->val) &&
(NULL == root->right || rightR.minV > root->val))
{
int minV = NULL == root->left ? root->val : leftR.minV;
int maxV = NULL == root->right ? root->val : rightR.maxV;
return Result(true, minV, maxV);
}
return Result(false, 0, 0);
}
bool BST::isBSTHelper(Node *node){
if(node->left == NULL && node-> right == NULL){
return true;
}
else if(node->left && node-> right){
if(node->left->data < node->data && node->right->data > node->data){
return isBSTHelper(node->left) && isBSTHelper(node->right);
}
}
else if(node->left && (node-> right)){
if(node->left->data < node->data){
return isBSTHelper(node->left);
}
else {
return false;
}
}
else if(!(node->left) && node-> right){
if(node->right->data > node->data){
return isBSTHelper(node->right);
}
else {
return false;
}
}
return true;
}
bool isBSTHelper(TreeNode *node, int minVal, int maxVal) {
if (node == NULL)
return true;
else if (node->val <= minVal || node->val >= maxVal)
return false;
else
return isBSTHelper(node->left, minVal, node->val) && isBSTHelper(node->right, node->val, maxVal);
}
/* returns 1 if each node has data >= min and <= max
*/
int isBSTHelper(Node *node, int min, int max)
{
/* base case 1: an empty tree is a well-formed BST */
if (node == NULL)
return 1;
/* base case 2: tree is not well formed */
if (node->data < min || node->data > max) {
return 0;
}
/* recursively check all the nodes, left and right */
return
isBSTHelper(node->left, min, node->data - 1) &&
isBSTHelper(node->right, node->data+1, max);
}
bool isBSTHelper(TreeNode* root, int& prev) {
if (!root) return true;
if (!(isBSTHelper(root->left, prev))) {
std::cout << "1" << std::endl;
return false;
}
if (!((root->val> prev) && (prev = root->val))) {
std::cout << "2" << std::endl;
return false;
}
if (!isBSTHelper(root->right, prev)) {
std::cout << "3" << std::endl;
return false;
}
return true;
}
int treeIsWellformed(void)
{
/* checks whether the tree is well-formed */
Node *currentNode;
currentNode = root;
return isBSTHelper(currentNode, INT_MIN, INT_MAX);
}
//Check if a given tree is a BST
bool BST::isBST(){
if(root == NULL){
cout<<endl<<"Empty tree"<<endl;
return true;
}
else{
return isBSTHelper(root);
}
}
bool isValidBST(TreeNode *root) {
// write your code here
return isBSTHelper(root).isBST;
}
bool isValidBST(TreeNode *root) {
return isBSTHelper(root, INT_MIN, INT_MAX);
}
bool isBST(TreeNode *root) {
int prev = INT_MIN;
return isBSTHelper(root, prev);
}
bool isBSTHelper(TreeNode *root, int rangeBegin, int rangeEnd) {
if (!root) return true;
if (root->val <= rangeBegin || root->val >= rangeEnd) return false;
return isBSTHelper(root->left, rangeBegin, root->val) && isBSTHelper(root->right, root->val, rangeEnd);
}
