算法 - 二叉树06（Swift版本）

题目1： 530.二叉搜索树的最小绝对差

讲解    
leetcode

// 递归法
class Solution {
    var res = Int.max
    var preNode: TreeNode?

    func getMinimumDifference(_ root: TreeNode?) -> Int {
        recursiveMin(root)
        return res
    }

    func recursiveMin(_ root: TreeNode?) {
        guard let root else { return }
        recursiveMin(root.left)
        if let preNode {
            res = min(res, root.val - preNode.val)            
        }
        preNode = root
        recursiveMin(root.right)
    }
}

// 迭代法
class Solution {
    var res = Int.max
    var preNode: TreeNode?

    func getMinimumDifference(_ root: TreeNode?) -> Int {
        var stack: [TreeNode?] = [root]
        while !stack.isEmpty {
            let node = stack.removeLast()
            if let node {
                if let right = node.right { stack.append(right) }
                stack.append(node)
                stack.append(nil)
                if let left = node.left { stack.append(left) }
            } else {
                let trueNode = stack.removeLast()
                if let trueNode, let preNode { res = min(res, trueNode.val - preNode.val) }
                preNode = trueNode
            }
        }
        return res
    }
}

题目2：501.二叉搜索树中的众数

讲解    
leetcode

// 递归法
class Solution {
    var preNode: TreeNode?
    var res = [Int]()
    var maxCount = 0
    var count = 0
    func findMode(_ root: TreeNode?) -> [Int] {
        bstRecursive(root)
        return res
    }
    func bstRecursive(_ root: TreeNode?) {
        guard let root else { return }
        bstRecursive(root.left)
        if let preNode {
            if preNode.val == root.val {
                count += 1
            } else {
                count = 0
            }
        } 
        preNode = root
        if count == maxCount {
            res.append(root.val)
        }
        if count > maxCount {
            maxCount = count
            res.removeAll()
            res.append(root.val)
        }

        bstRecursive(root.right)
    }
}

// 递归法
class Solution {
    func findMode(_ root: TreeNode?) -> [Int] {
        var stack: [TreeNode?] = [root]
        var preNode: TreeNode?
        var res = [Int]()
        var count = 0
        var maxCount = 0
        while !stack.isEmpty {
            let node = stack.removeLast()
            if let node {
                if let right = node.right { stack.append(right) }
                stack.append(node)
                stack.append(nil)
                if let left = node.left { stack.append(left) }
            } else {
                let trueNode = stack.removeLast()
                if let preNode, let trueNode {
                    if preNode.val == trueNode.val {
                        count += 1
                    } else {
                        count = 0
                    }
                }
                preNode = trueNode

                if count == maxCount {
                    res.append(trueNode?.val ?? 0)
                }
                if count > maxCount {
                    maxCount = count
                    res.removeAll()
                    res.append(trueNode?.val ?? 0)
                }
            }
        }
        return res
    }
}

题目3： 236. 二叉树的最近公共祖先

讲解
leetcode

视频讲解真的很赞。

class Solution {
    func lowestCommonAncestor(_ root: TreeNode?, _ p: TreeNode?, _ q: TreeNode?) -> TreeNode? {
        if root == nil { return nil }
        if root === p || root === q { return root }
        let left = lowestCommonAncestor(root?.left, p, q)
        let right = lowestCommonAncestor(root?.right, p, q)
        if left != nil, right != nil { return root }
        else if left == nil, right == nil { return nil }
        else if left != nil { return left }
        else { return right }
    }
}