[Swift]LeetCode98. 验证二叉搜索树 | Validate Binary Search Tree

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址：https://www.cnblogs.com/strengthen/p/9937199.html 
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

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:

Input:
    2
   / 
  1   3
Output: true

Example 2:

    5
   / 
  1   4
     / 
    3   6
Output: false
Explanation: The input is: [5,1,4,null,null,3,6]. The root node's value
             is 5 but its right child's value is 4.

---

给定一个二叉树，判断其是否是一个有效的二叉搜索树。

假设一个二叉搜索树具有如下特征：

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

示例 1:

输入:
    2
   / 
  1   3
输出: true

示例 2:

输入:
    5
   / 
  1   4
     / 
    3   6
输出: false
解释: 输入为: [5,1,4,null,null,3,6]。
     根节点的值为 5 ，但是其右子节点值为 4 。

---

28ms

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public var val: Int
 *     public var left: TreeNode?
 *     public var right: TreeNode?
 *     public init(_ val: Int) {
 *         self.val = val
 *         self.left = nil
 *         self.right = nil
 *     }
 * }
 */
class Solution {
    func isValidBST(_ root: TreeNode?) -> Bool {
        return isValidBSTRecursive(root, Int.min, Int.max)
    }
    
    func isValidBSTRecursive(_ node: TreeNode?, _ min: Int, _ max: Int) -> Bool {
        if let currentNode = node {
            if currentNode.val < max && currentNode.val > min &&
                isValidBSTRecursive(currentNode.left, min, currentNode.val) &&
                isValidBSTRecursive(currentNode.right, currentNode.val, max) {
                    return true
            }   
        } else {
            return true
        }
        return false;
    }
}

---

32ms

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public var val: Int
 *     public var left: TreeNode?
 *     public var right: TreeNode?
 *     public init(_ val: Int) {
 *         self.val = val
 *         self.left = nil
 *         self.right = nil
 *     }
 * }
 */
class Solution {
  func isValidBST(_ root: TreeNode?, _ lowerBound: Int? = nil, _ upperBound: Int? = nil) -> Bool {
    guard let root = root else { return true }
    if let upper = upperBound, root.val >= upper { return false }
    if let lower = lowerBound, root.val <= lower { return false }
    if let left = root.left, left.val >= root.val { return false }
    if let right = root.right, right.val <= root.val { return false }
    let leftUpperBound = upperBound.map { max($0, root.val) } ?? root.val
    let rightLowerBound = lowerBound.map { min($0, root.val) } ?? root.val
    return isValidBST(root.left, lowerBound, leftUpperBound) && isValidBST(root.right, rightLowerBound, upperBound)
  }
}

---

36ms

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public var val: Int
 *     public var left: TreeNode?
 *     public var right: TreeNode?
 *     public init(_ val: Int) {
 *         self.val = val
 *         self.left = nil
 *         self.right = nil
 *     }
 * }
 */
class Solution {
    func isValidBST(_ root: TreeNode?) -> Bool {
        if root == nil {return true}
        var root = root
        var stack = [TreeNode]()
        var prev :TreeNode? = nil
        while root != nil || !stack.isEmpty{
            while root != nil {
                stack.append(root!)
                root = root?.left
            }
            root = stack.popLast()
            if prev != nil && root!.val <= prev!.val {return false}
            prev = root
            root = root?.right
            
        }
        return true
    }
}

---

44ms

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public var val: Int
 *     public var left: TreeNode?
 *     public var right: TreeNode?
 *     public init(_ val: Int) {
 *         self.val = val
 *         self.left = nil
 *         self.right = nil
 *     }
 * }
 */
class Solution {
    func isValidBST(_ root: TreeNode?) -> Bool {
        guard let root = root else {
            return true
        }
        
        return helper(root, Int.min, Int.max)
        
    }
    
    func helper(_ root: TreeNode?, _ min: Int, _ max: Int) -> Bool {
        guard let root = root else {
            return true
        }
        
        if let leftVal = root.left?.val {
            if leftVal >= root.val {
                return false
            }
        }
        
        if let rightVal = root.right?.val {
            if rightVal <= root.val{
                return false
            }
        }
        
        if root.val <= min || root.val >= max {
            return false
        }

        return helper(root.left, min, root.val) && helper(root.right, root.val, max)
    }
}

---

60ms

class Solution {
    func isValidBST(_ root: TreeNode?) -> Bool {
        return _helper(root, nil ,nil)
    }
    
    private func _helper(_ node: TreeNode?, _ min: Int?, _ max: Int?) -> Bool {
      guard let node = node else {
        return true
      }
      // 所有右子节点都必须大于根节点
      if let min = min, node.val <= min {
        return false
      }
      // 所有左子节点都必须小于根节点
      if let max = max, node.val >= max {
        return false
      }

      return _helper(node.left, min, node.val) && _helper(node.right, node.val, max)
    }
}

---

 64ms

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public var val: Int
 *     public var left: TreeNode?
 *     public var right: TreeNode?
 *     public init(_ val: Int) {
 *         self.val = val
 *         self.left = nil
 *         self.right = nil
 *     }
 * }
 */
class Solution {
    func isValidBST(_ root: TreeNode?) -> Bool {
        return isValidBSTUtil(root, min: Int.min, max: Int.max)
    }
    
    func isValidBSTUtil(_ node: TreeNode?, min: Int, max: Int) -> Bool {
        guard let node = node else { return true }
        guard node.val > min && node.val < max else { return false }
        return isValidBSTUtil(node.left, min: min, max: node.val) && isValidBSTUtil(node.right, min: node.val, max: max) 
    }
}

---

84ms

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public var val: Int
 *     public var left: TreeNode?
 *     public var right: TreeNode?
 *     public init(_ val: Int) {
 *         self.val = val
 *         self.left = nil
 *         self.right = nil
 *     }
 * }
 */
 /*
 思路:
 1.左边子树一定小于根节点的父节点,节点层级越高,数值越大
 2.右边子树一定大约根节点的父节点,节点层级越高,数值越小
  */
class Solution {
    func isValidBST(_ root: TreeNode?) -> Bool {
        return isValidBST(root, Int.min, Int.max)
    }
    
    func isValidBST(_ root:TreeNode?, _ min:Int, _ max:Int) -> Bool {
        if (root == nil) {
            return true
        }
        
        if (root?.val)! <= min || (root?.val)! >= max {
            return false
        }
        
        return isValidBST(root?.left, min, (root?.val)!) && isValidBST(root?.right, (root?.val)!, max)
    }
}