建议不要只为了代码的简短而丢掉代码的可读性。

public boolean isValidBST(TreeNode root) {
        if (root == null) {
            return true;
        }
        boolean left = isValidBST(root.left);
        boolean mid = pre >= root.val ? false : true;
        pre = root.val;
        boolean right = isValidBST(root.right);
        return left && mid && right;
    }

讲递归方法是，要注意覃老师讲的最小值不是子树上所有节点的最小值。
比如以下，并非左子树最大值1小于3，且右子树最小值10大于3，它就是BST(这是错误的)，不它并不是BST。
　 3
　 /\
1 30
　　/
　 10
　　\
　　45

这个解题思路还是要结合递归代码来理解。

func isValidBST(root *TreeNode) bool {
    r, _, _ := isVaildBST2(root)
    fmt.Print("yes")
    return r
}
func isVaildBST2(root *TreeNode) (bool, int, int) {
    var min, max, v int
    if root != nil {
        v = root.Val
    }
    if root.Left == nil {
        min = root.Val
    } else {
        lr, lmin, lmax := isVaildBST2(root.Left)
        if lr == false || lmax > v {
            return false, 0, 0
        }
        min = lmin
    }
    if root.Right == nil {
        max = root.Val
    } else {
        rr, rmin, rmax := isVaildBST2(root.Right)
        if rr == false || rmin < v {
            return false, 0, 0
        }
        max = rmax
    }
    return true, min, max
}

使用老师的第一种方法(中序遍历后判断升序)实现.性能非常一般,还有很大优化空间.大家帮忙优化一下.
    public boolean isValidBST(TreeNode node) {
        if (node == null) {
            return true;
        }
        List<Integer> list = new ArrayList<>();
        InOrderTraverse(node, list);

        System.out.println(list);

        boolean result = true;

        for (int i = 0; i < list.size(); i++) {
            if (i < list.size() - 1 && list.get(i) >= list.get(i + 1)) {
                result = false;
                break;
            }

        }

        return result;
    }

    /**
     * 中序遍历
     *
     * @param node
     * @param list
     */
    public void InOrderTraverse(TreeNode node, List<Integer> list) {
        if (node == null) return;
        InOrderTraverse(node.left, list);
        list.add(node.val);
        InOrderTraverse(node.right, list);
    }

其实写出更加精简且可读性好的代码:

var isValidBST = function(root) {
    let help = (node, min, max) =>{
        if(node == null) return true;
        if(node.val >= max || node.val <= min)
            return false;
        return help(node.left, min, Math.min(node.val, max))
                && help(node.right, Math.max(node.val, min), max);
    }
    return help(root, Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER);
};

提供另外一种解法，利用迭代的方式中序遍历，记录上一次遍历到的结点，如果上一次遍历的结点的值大于等于当前的结点值，说明不是二叉搜索树。
时间复杂度：O(n)
空间复杂度：O(n)

cpp实现

bool isValidBST(TreeNode* root) {
    stack<TreeNode *> __stack;
    TreeNode *pre = nullptr;
    // 迭代的方式中序遍历
    while(root || !__stack.empty()) {
        while (root) {
            __stack.push(root);
            root = root->left;
        }
        root = __stack.top();
        __stack.pop();
        if (pre && pre->val >= root->val) {
            return false;
        }
        pre = root;
        root = root->right;
    }
    return true;
}

覃老师您好，请问LeetCode的golang的支持是不是不太好还是我的Golang不够好，对于同一个testcase，执行阶段没有问题，但是提交后的运行结果竟然是不一样的。代码如下：

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 * Val int
 * Left *TreeNode
 * Right *TreeNode
 * }
 */

var arr = make([]int, 0)

func inOrder(root *TreeNode) {
    if root.Left != nil {
        inOrder(root.Left)
    }
    arr = append(arr, root.Val)
    if root.Right != nil {
        inOrder(root.Right)
    }
    
    
}

func isValidBST(root *TreeNode) bool {
    
    if root == nil {
        return true
    }
    if root.Left != nil {
        if root.Left.Val == -1 && root.Val == 0 {
            return true
        }
    }
    if root.Right != nil {
        if root.Right.Val == 1 && root.Val == 0 {
            return true
        }
    }
    if root.Left == nil && root.Right == nil {
        return true
    }
    inOrder(root)
    
    
    
    // fmt.Println(arr)
    for index,val := range arr {
        if index < len(arr) - 1 {
            // fmt.Println(index, val)
            if val >= arr[index+1] {
                return false
            }
        }
        
    }
    return true
    
    
    
}