开涮力扣：2、验证二叉搜索树

1.题目

给你一个二叉树的根节点 root ，判断其是否是一个有效的二叉搜索树。

有效 二叉搜索树定义如下：

节点的左子树只包含 小于 当前节点的数。
节点的右子树只包含 大于 当前节点的数。
所有左子树和右子树自身必须也是二叉搜索树。

示例 1：

输入：root = [2,1,3]
输出：true

示例 2：

输入：root = [5,1,4,null,null,3,6]
输出：false
解释：根节点的值是 5 ，但是右子节点的值是 4 。

 提示：

• 树中节点数目范围在[1, 10^4] 内
• -2^31 <= Node.val <= 2^31 - 1

2.二叉树的遍历 

参见二叉树的四种遍历方式 - 林海杜 - 博客园，相干内容摘录如下

（1）中序遍历：左-> 根-> 右，DBEFAGHCI

    public static void inOrderTraveral(TreeNode node){
        if(node == null){
            return;
        }
        inOrderTraveral(node.leftChild);
        System.out.print(node.data+" ");
        inOrderTraveral(node.rightChild);
    }

中序遍历非递归，具体过程：

1. 申请一个新栈，记为stack，申请一个变量cur，初始时令treeNode为头节点；
2. 先把treeNode节点压入栈中，对以treeNode节点为头的整棵子树来说，依次把整棵树的左子树压入栈中，即不断令treeNode=treeNode.leftChild，然后重复步骤2；
3. 不断重复步骤2，直到发现cur为空，此时从stack中弹出一个节点记为treeNode，打印node的值，并让treeNode= treeNode.right，然后继续重复步骤2；
4. 当stack为空并且cur为空时结束。

public static void inOrderTraveralWithStack(TreeNode node){
        Stack<TreeNode> stack = new Stack<TreeNode>();
        TreeNode treeNode = node;
        while(treeNode!=null || !stack.isEmpty()){
            while(treeNode != null){
                stack.push(treeNode);
                treeNode = treeNode.leftChild;
            }
            if(!stack.isEmpty()){
                treeNode = stack.pop();
                System.out.print(treeNode.data+" ");
                treeNode = treeNode.rightChild;
            }

        }
    }

（2）先序遍历：根-> 左-> 右

    public static void preOrderTraveral(TreeNode node){
        if(node == null){
            return;
        }
        System.out.print(node.data+" ");
        preOrderTraveral(node.leftChild);
        preOrderTraveral(node.rightChild);
    }

非递归前序遍历

1. 首先申请一个新的栈，记为stack；
2. 声明一个结点treeNode，让其指向node结点；
3. 如果treeNode的不为空，将treeNode的值打印，并将treeNode入栈，然后让treeNode指向treeNode的左结点，
4. 重复步骤3，直到treenode为空；
5. 然后出栈，让treeNode指向treeNode的右孩子
6. 重复步骤3，直到stack为空.

public static void preOrderTraveralWithStack(TreeNode node){
        Stack<TreeNode> stack = new Stack<TreeNode>();
        TreeNode treeNode = node;
        while(treeNode!=null || !stack.isEmpty()){
            //迭代访问节点的左孩子，并入栈
            while(treeNode != null){
                System.out.print(treeNode.data+" ");
                stack.push(treeNode);
                treeNode = treeNode.leftChild;
            }
            //如果节点没有左孩子，则弹出栈顶节点，访问节点右孩子
            if(!stack.isEmpty()){
                treeNode = stack.pop();
                treeNode = treeNode.rightChild;
            }
        }
    }

（3）后序遍历：左-> 右-> 根

    public static void postOrderTraveral(TreeNode node){
        if(node == null){
            return;
        }
        postOrderTraveral(node.leftChild);
        postOrderTraveral(node.rightChild);
        System.out.print(node.data+" ");
    }

3.代码 

#include <stack>
class Solution {
public:
    bool isValidBST(TreeNode* root) { 
        //中序遍历非递归       
            stack <TreeNode*> stnode;
            TreeNode *p=root,*pre=NULL;
        
            while(!stnode.empty() || p){
                while(p)
                {
                    stnode.push(p);
                    p=p->left;
                }
                TreeNode *temp=stnode.top();
                stnode.pop();
                if(pre && pre->val >= temp->val) return false;
                pre=temp;
                p=temp->right;  
            }
            return true;              
    }
};

 这是中序遍历非递归写法，判断当前节点是否大于中序遍历的前一个节点。