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

知识讲解

题目1： 226.翻转二叉树

讲解
leetcode

// 递归法
class Solution {
    func invertTree(_ root: TreeNode?) -> TreeNode? {
        guard let root else { return nil }
        (root.left, root.right) = (root.right, root.left)
        invertTree(root.left)
        invertTree(root.right)
        return root
    }
}

// 迭代法
class Solution {
    func invertTree(_ root: TreeNode?) -> TreeNode? {
        guard let root else { return nil }
        var stack = [root]
        while !stack.isEmpty {
            let node = stack.removeLast()
            (node.left, node.right) = (node.right, node.left)
            if let left = node.left { stack.append(left) }
            if let right = node.right { stack.append(right) }
        }
        return root
    }
}

// 统一迭代写法
class Solution {
    func invertTree(_ root: TreeNode?) -> TreeNode? {
        guard let root else { return nil }
        var stack: [TreeNode?] = [root]
        var cur = root
        while !stack.isEmpty {
            // 按照遍历顺序的逆序压栈
            var cur = stack.removeLast()
            if let cur {
                if let right = cur.right { stack.append(right) }
                if let left = cur.left { stack.append(left) }
                stack.append(cur)
                stack.append(nil)
            } else {
                // 解包
                if let node = stack.removeLast() {
                    (node.left, node.right) = (node.right, node.left)
                }
            }
        }
        return root
    }
}

题目2： 101. 对称二叉树

讲解  

leetcode

// 递归法
class Solution {
    func isSymmetric(_ root: TreeNode?) -> Bool {
        compare(root?.left, root?.right)
    }

    func compare(_ left: TreeNode?, _ right: TreeNode?) -> Bool {
        if left == nil, right == nil { return true }
        else if left == nil, right != nil { return false }
        else if left != nil, right == nil { return false }
        else if left?.val != right?.val { return false }

        let res1 = compare(left?.left, right?.right)
        let res2 = compare(left?.right, right?.left)
        return res1 && res2
    }
}

// 迭代法
class Solution {
    func isSymmetric(_ root: TreeNode?) -> Bool {
        guard let root else { return true }
        var stack = [TreeNode?]()
        stack.append(root.left)
        stack.append(root.right)
        while !stack.isEmpty {
            let right = stack.removeLast()
            let left = stack.removeLast()
            if left == nil && right == nil { continue }
            if left == nil || right == nil || left?.val != right?.val { return false }
            stack.append(left?.left)
            stack.append(right?.right)
            stack.append(left?.right)
            stack.append(right?.left)            
        }
        return true
    }
}

题目3： 104.二叉树的最大深度

讲解  

leetcode

// 递归法
class Solution {
    func maxDepth(_ root: TreeNode?) -> Int {
        guard let root else { return 0 }
        return 1 + max(maxDepth(root.left), maxDepth(root.right))
    }
}

题目4：111.二叉树的最小深度

讲解  

leetcode

层序遍历好理解些，递归还得多看看。

class Solution {
    func minDepth(_ root: TreeNode?) -> Int {
        if root == nil { return 0 }
        var queue = [root]
        var depth = 0
        while !queue.isEmpty {
            let size = queue.count
            depth += 1
            for _ in 0..<size {
                let node = queue.removeFirst()
                if let left = node?.left { queue.append(left) }
                if let right = node?.right { queue.append(right) }
                if node?.left == nil, node?.right == nil {
                    return depth
                }
            }
        }
        return depth
    }
}