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.

這道驗證二叉搜尋樹有很多種解法，可以利用它本身的性質來做，即左<根<右，也可以通過利用中序遍歷結果為有序數列來做，下面我們先來看最簡單的一種，就是利用其本身性質來做，初始化時帶入系統最大值和最小值，在遞迴過程中換成它們自己的節點值，用long代替int就是為了包括int的邊界條件，程式碼如下：

C++ 解法一：

// Recursion without inorder traversal
class Solution {
public:
    bool isValidBST(TreeNode *root) {
        return isValidBST(root, LONG_MIN, LONG_MAX);
    }
    
 
bool isValidBST(TreeNode *root, long mn, long mx) {
        if (!root) return true;
        if (root->val <= mn || root->val >= mx) return false;
        return isValidBST(root->left, mn, root->val) && isValidBST(root->right, root->val, mx);
    }
};

Java 解法一：

public class Solution {
    public boolean isValidBST(TreeNode root) {
        if (root == null) return true;
        return valid(root, Long.MIN_VALUE, Long.MAX_VALUE);
    }
    public boolean valid(TreeNode root, long low, long high) {
        if (root == null) return true;
        if (root.val <= low || root.val >= high) return false;
        return valid(root.left, low, root.val) && valid(root.right, root.val, high);
    }
}

這題實際上簡化了難度，因為一般的二叉搜尋樹是左<=根<右，而這道題設定為左<根<右，那麼就可以用中序遍歷來做。因為如果不去掉左=根這個條件的話，那麼下邊兩個數用中序遍歷無法區分：

   20       20
   /           \
 20           20

它們的中序遍歷結果都一樣，但是左邊的是BST，右邊的不是BST。去掉等號的條件則相當於去掉了這種限制條件。下面我們來看使用中序遍歷來做，這種方法思路很直接，通過中序遍歷將所有的節點值存到一個數組裡，然後再來判斷這個陣列是不是有序的，程式碼如下：

C++ 解法二：

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

Java 解法二：

public class Solution {
    public boolean isValidBST(TreeNode root) {
        List<Integer> list = new ArrayList<Integer>();
        inorder(root, list);
        for (int i = 0; i < list.size() - 1; ++i) {
            if (list.get(i) >= list.get(i + 1)) return false;
        }
        return true;
    }
    public void inorder(TreeNode node, List<Integer> list) {
        if (node == null) return;
        inorder(node.left, list);
        list.add(node.val);
        inorder(node.right, list);
    }
}

下面這種解法跟上面那個很類似，都是用遞迴的中序遍歷，但不同之處是不將遍歷結果存入一個數組遍歷完成再比較，而是每當遍歷到一個新節點時和其上一個節點比較，如果不大於上一個節點那麼則返回false，全部遍歷完成後返回true。程式碼如下：

C++ 解法三：

// Still recursion
class Solution {
public:
    TreeNode *pre;
    bool isValidBST(TreeNode *root) {
        int res = 1;
        pre = NULL;
        inorder(root, res);
        if (res == 1) return true;
        else false;
    }
    void inorder(TreeNode *root, int &res) {
        if (!root) return;
        inorder(root->left, res);
        if (!pre) pre = root;
        else {
            if (root->val <= pre->val) res = 0;
            pre = root;
        }
        inorder(root->right, res);
    }
};

當然這道題也可以用非遞迴來做，需要用到棧，因為中序遍歷可以非遞迴來實現，所以只要在其上面稍加改動便可，程式碼如下：

C++ 解法四：

// Non-recursion with stack
class Solution {
public:
    bool isValidBST(TreeNode* root) {
        stack<TreeNode*> s;
        TreeNode *p = root, *pre = NULL;
        while (p || !s.empty()) {
            while (p) {
                s.push(p);
                p = p->left;
            }
            TreeNode *t = s.top(); s.pop();
            if (pre && t->val <= pre->val) return false;
            pre = t;
            p = t->right;
        }
        return true;
    }
};

Java 解法四：

public class Solution {
    public boolean isValidBST(TreeNode root) {
        Stack<TreeNode> s = new Stack<TreeNode>();
        TreeNode p = root, pre = null;
        while (p != null || !s.empty()) {
            while (p != null) {
                s.push(p);
                p = p.left;
            }
            TreeNode t = s.pop();
            if (pre != null && t.val <= pre.val) return false;
            pre = t;
            p = t.right;
        }
        return true;
    }
}

最後還有一種方法，由於中序遍歷還有非遞迴且無棧的實現方法，稱之為Morris遍歷，可以參考我之前的部落格 Binary Tree Inorder Traversal，這種實現方法雖然寫起來比遞迴版本要複雜的多，但是好處在於是O(1)空間複雜度，參見程式碼如下：

C++ 解法五:

class Solution {
public:
    bool isValidBST(TreeNode *root) {
        if (!root) return true;
        TreeNode *cur = root, *pre, *parent = NULL;
        bool res = true;
        while (cur) {
            if (!cur->left) {
                if (parent && parent->val >= cur->val) res = false;
                parent = cur;
                cur = cur->right;
            } else {
                pre = cur->left;
                while (pre->right && pre->right != cur) pre = pre->right;
                if (!pre->right) {
                    pre->right = cur;
                    cur = cur->left;
                } else {
                    pre->right = NULL;
                    if (parent->val >= cur->val) res = false;
                    parent = cur;
                    cur = cur->right;
                }
            }
        }
        return res;
    }
};

類似題目：

參考資料：