Validate Binary Search Tree (leetcode)

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.

confused what "{1,#,2,3}" means? > read more on how binary tree is serialized on OJ.

OJ's Binary Tree Serialization:

The serialization of a binary tree follows a level order traversal, where '#' signifies a path terminator where no node exists below.

Here's an example:

   1
  / \
 2   3
    /
   4
    \
     5

The above binary tree is serialized as "{1,2,3,#,#,4,#,#,5}".

https://oj.leetcode.com/problems/validate-binary-search-tree/

1> 对于二叉搜索树，中序遍历是有序的，通过中序遍历，可以判断二叉树是否是二叉搜索树(Binary Search Tree).

    1.1> 首先介绍递归版本 code：

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    bool isValidBST(TreeNode *root) {
		int val = INT_MIN;
		return isBST(root, val);
    }
    
    bool isBST(TreeNode *root, int &prev_val) {
		//inorder traversal of binary tree,and keep tarck of prev node's val
		if (root){
			if (!isBST(root->left, prev_val)) {
				return false;
			}
			if (root->val <= prev_val) {
				return false;
			}
			prev_val = root->val;
			if (!isBST(root->right, prev_val)) {
				return false;
			}
		}
		return true;
    }
};

 1.2> 中序遍历非递归版本：

/**
 * Definition for binary tree
 * 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) {
			return true;
		}
		//inorder traversal of binary tree,and keep tarck of prev node's val
		int prev_val = INT_MIN;
		std::stack<TreeNode *> mystack;
		TreeNode *curr = root;

		while (curr || !mystack.empty()) {
			while (curr) {
				//put the left child to stack 
				mystack.push(curr);
				curr = curr->left;
			}
			curr = mystack.top();
			if (prev_val >= curr->val) {
				return false;
			} else {
				prev_val = curr->val;
			}
			curr = curr->right;
			mystack.pop();
		}
		return true;
    }
};

2.  采用前序遍历二叉树方式访问，指定最大边界和最小边界，通过递归访问，判断节点是否在指定范围内，成功返回true，失败返回false

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    bool isValidBST(TreeNode *root) {
        isBST(root, INT_MIN, INT_MAX);
    }
    
    bool isBST(TreeNode *root, int min, int max) {
		if (!root) {
			return true;
		}
		if (root->val >max || root->val < min) {
			return false;
		}
		return (isBST(root->left, min, root->val - 1) && isBST(root->right, root->val + 1, max));
	}
};