LeetCode--98--medium--ValidateBinarySearchTree

package com.app.main.LeetCode.tree;

import com.app.main.LeetCode.base.TreeNode;

import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

/**
 *
 * 98
 *
 * medium
 *
 * https://leetcode.com/problems/validate-binary-search-tree/
 *
 * 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.
 *
 *
 * Example 1:
 *
 *     2
 *    / \
 *   1   3
 *
 * Input: [2,1,3]
 * Output: true
 * Example 2:
 *
 *     5
 *    / \
 *   1   4
 *      / \
 *     3   6
 *
 * Input: [5,1,4,null,null,3,6]
 * Output: false
 * Explanation: The root node's value is 5 but its right child's value is 4.
 *
 *
 * Created with IDEA
 * author:Dingsheng Huang
 * Date:2019/11/6
 * Time:下午6:14
 */
public class ValidateBinarySearchTree {


    // BFS
    public boolean isValidBST(TreeNode root) {
        return validate(root, null, null);
    }

    private boolean validate(TreeNode curr, Integer min, Integer max) {
        if (curr == null) {
            return true;
        }

        if (min != null && curr.val <= min) {
            return false;
        }

        if (max != null && curr.val >= max) {
            return false;
        }
        return validate(curr.left, min, curr.val) && validate(curr.right, curr.val, max);
    }



    // DFS
    public boolean isValidBST3(TreeNode root) {
        // in-order traversal
        Stack<TreeNode> stack = new Stack<>();
        TreeNode curr = root;
        double pre = -Double.MAX_VALUE;
        while (!stack.isEmpty() || curr != null) {
            while (curr != null) {
                stack.push(curr);
                curr = curr.left;
            }

            curr = stack.pop();
            if (curr.val <= pre) {
                return false;
            }
            pre = curr.val;
            curr = curr.right;
        }
        return true;
    }










    // 其它思考过程。。
    public boolean isValidBST1(TreeNode root) {

        List<Integer> list =  new ArrayList<>();
        inOrderTraversal(root, list);
        if (list.size() <= 1) {
            return true;
        }
        for (int i = 1; i < list.size(); i++) {
            if (list.get(i) <= list.get(i - 1)) {
                return false;
            }
        }
        return true;
    }

    public boolean inOrderTraversal(TreeNode root, List<Integer> result) {
        if (root != null) {
            if (root.left != null) {
                inOrderTraversal(root.left, result);
            }
            result.add(root.val);
            if (result.size() > 1) {
                if (result.get(result.size() - 1) <= result.get(result.size() - 2)) {
                    return false;
                }
            }
            if (root.right != null) {
                inOrderTraversal(root.right, result);
            }
        }
        return true;
    }


    public boolean isValidBST2(TreeNode root) {

        if (root == null) {
            return true;
        }
        return validate(root, root.val) && isValidBST2(root.left) &&  isValidBST2(root.right);

    }

    private boolean validate(TreeNode root, int val) {
        if (root == null) {
            return true;
        }
        return validate1(root.left, val) && validate2(root.right, val);
    }

    private boolean validate1(TreeNode root, int val) {
       if (root == null) {
           return true;
       }
       if (root.val >= val) {
           return false;
       }
       return validate1(root.left, val) && validate1(root.right, val);
    }

    private boolean validate2(TreeNode root, int val) {
        if (root == null) {
            return true;
        }
        if (root.val <= val) {
            return false;
        }
        return validate2(root.left, val) && validate2(root.right, val);
    }














}