0x00 题目

给你一棵二叉树的根节点 ​​root​​，翻转它。

0x01 思路

​​翻转​​​，就是把左、右节点​​交换​​​过来。
既然要交换，就不能只交换​​​一个​​​节点。
所以要交换全部，那就得​​​遍历​​​​遍历​​ 方式有：
​​深度​​优先：​​前序​​遍历，​​中序​​遍历，​​后序​​遍历
​​广度​​优先：​​层序​​遍历

然而，这里有一个​​坑​​，后面说…

0x02 解法

语言：​​Swift​​

树节点：​​TreeNode​​

public class TreeNode {
    public var val: Int
    public var left: TreeNode?
    public var right: TreeNode?
    public init() { self.val = 0; self.left = nil; self.right = nil; }
    public init(_ val: Int) { self.val = val; self.left = nil; self.right = nil; }
    public init(_ val: Int, _ left: TreeNode?, _ right: TreeNode?) {
        self.val = val
        self.left = left
        self.right = right
    }
}

​​深度​​优先:

func invertTree(_ root: TreeNode?) -> TreeNode? {
    // 节点为空，该回头了
    guard let root = root else { return nil }
    
    // 前序遍历代码  -> 见下面的具体代码
    invertTree(root.left)
    // 中序遍历代码  -> 见下面的具体代码
    invertTree(root.right)
    // 后序遍历代码  -> 见下面的具体代码
    
    return root
}

具体代码：

    let node = root.left
    root.left = root.right
    root.right = node
    
    // (root.left, root.right) = (root.right, root.left)

其中，上面所说的​​坑​​​，就在​​中序​​遍历 的位置

中序遍历顺序是：左中右（左节点，根节点，右节点）
左：交换左节点的，​​​左子​​​节点与​​右子​​​节点
中：交换，左节点换到右边去了
右：交换，其实是在操作​​​左​​​节点
最终，​​​右​​​节点没有进行交换
看！​​​坑​​ 就在这里

​​广度​​​优先：
先把​​​同一层​​​的所有节点，都翻转了，再去​​下一层​​

func invertTree(_ root: TreeNode?) -> TreeNode? {
    guard let root = root else {
        return nil
    }
    
    var queue: [TreeNode] = [root]
    while !queue.isEmpty {
        // 用来保存下一层的节点
        var tmp: [TreeNode] = []

        while !queue.isEmpty {
            let node = queue.removeFirst()
            // 交换
            (node.left, node.right) = (node.right, node.left)

            if let left = node.left {
                tmp.append(left)
            }

            if let right = node.right {
                tmp.append(right
            }
        }

        queue = tmp
    }

    return root
}

小五笔

​​最强​​​用户 ​​1​​ 天学会！敢来挑战？