1084 字
5 分钟
从上到下花式打印二叉树
前言
二叉树的常规便利： 前序遍历 、 中序遍历 、 后序遍历 可能都已经非常熟悉了。
本文将结合一个题目的三种形态来玩一下花式遍历。
一、 顺序打印
1.1 题目
从上到下打印出二叉树的每个节点，同一层的节点按照从左到右的顺序打印。
例如:
给定二叉树: [3,9,20,null,null,15,7],
3 / \ 9 20 / \ 15 7返回：
[3,9,20,15,7]提示：
节点总数 <= 1000
来源：力扣（LeetCode）
1.2 分析
由于二叉树并非一个有序队列，但题目要求我们有序的输出。此时可以考虑借助一个辅助队列进行解题。
通过分析我们可以找到规律：每次打印一个节点的时候，如果该节点存在子节点，则把该节点的子节点插入队列末尾。接下来从队列头部取出节点重复打印操作。直至所有节点打印完成。
| 当前节点 | 辅助队列 | 结果 |
|---|---|---|
| 3 | 9,20 | 3 |
| 9 | 20 | 3,9 |
| 20 | 15,7 | 3,9,20 |
| 15 | 7 | 3,9,20,15 |
| 7 | - | 3,9,20,15,7 |
1.3 编码
func levelOrder(_ root: TreeNode?) -> [Int] { guard let r = root else { return [] } var result: [Int] = [] var queue: [TreeNode] = [r]
while queue.isEmpty == false { let first = queue[0] result.append(first.val)
if let left = first.left { queue.append(left) }
if let right = first.right { queue.append(right) }
queue.removeFirst() }
return result}
二、 逐行打印
2.1 题目
从上到下按层打印二叉树，同一层的节点按从左到右的顺序打印，每一层打印到一行。
例如:
给定二叉树: [3,9,20,null,null,15,7],
3 / \ 9 20 / \ 15 7返回其层次遍历结果：
[ [3], [9,20], [15,7] ]2.2 分析
在第一种遍历的基础上，这本题加上了换行的逻辑。我们只需要加上换行的判断逻辑就可以了。
2.3 题解
func levelOrder(_ root: TreeNode?) -> [[Int]] { var queue: [TreeNode] = [] /// 当前行需要继续打印的数量 var toBePrint = 0 /// 下一行的数量 var nextLevelCount = 0 var result: [[Int]] = [] var temp: [Int] = []
if let r = root { queue.append(r) toBePrint += 1 }
while queue.isEmpty == false { if let first = queue.first { temp.append(first.val) queue.removeFirst() toBePrint -= 1
if let left = first.left { queue.append(left) nextLevelCount += 1 }
if let right = first.right { queue.append(right) nextLevelCount += 1 }
if toBePrint == 0 { result.append(temp) temp = []
toBePrint = nextLevelCount nextLevelCount = 0 } } }
return result}
三、 之字形打印
3.1 题目
请实现一个函数按照之字形顺序打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右到左的顺序打印，第三行再按照从左到右的顺序打印，其他行以此类推。
例如:
给定二叉树: [3,9,20,null,null,15,7],
3 / \ 9 20 / \ 15 7返回其层次遍历结果：
[ [3], [20,9], [15,7] ]3.2 易错点
本题很容易想当然的觉得和第二种差不多，左右换成右左就可以了嘛～于是稍微改一改就写出下面的代码：
func levelOrder(_ root: TreeNode?) -> [[Int]] { var queue: [TreeNode] = [] var toBePrint = 0 var nextLevelCount = 0 var result: [[Int]] = [] var temp: [Int] = []
var flag = false
if let r = root { queue.append(r) toBePrint += 1 }
while queue.isEmpty == false { if let first = queue.first { temp.append(first.val) queue.removeFirst() toBePrint -= 1
if flag { if let left = first.left { queue.append(left) nextLevelCount += 1 }
if let right = first.right { queue.append(right) nextLevelCount += 1 } } else { if let right = first.right { queue.append(right) nextLevelCount += 1 }
if let left = first.left { queue.append(left) nextLevelCount += 1 } }
if toBePrint == 0 { result.append(temp) temp = []
toBePrint = nextLevelCount nextLevelCount = 0
flag.toggle() } } }
return result}然后顺序就乱掉了：
3.3 分析
这里不将思维局限于遍历的方向。这里还是按顺序逐层便利。一个队列A存放当前行，一个队列B存放下一行的。当一行遍历完，将B赋值给A，再用B来存放下一行。而打印结果则根据当前行的方向决定是从头插入还是从末尾插入。
3.4 题解
func levelOrder(_ root: TreeNode?) -> [[Int]] { guard let r = root else { return [] }
var queue: [TreeNode] = [] var queueB: [TreeNode] = [] var toBePrint = 0 var nextLevelCount = 0 var result: [[Int]] = [] var flag = true
queue.append(r) toBePrint += 1
var temp = Array(repeating: 0, count: queue.count)
while queue.isEmpty == false { let first = queue.removeFirst() temp[flag ? (temp.count - toBePrint) : (toBePrint - 1)] = first.val toBePrint -= 1
if let left = first.left { queueB.append(left) nextLevelCount += 1 }
if let right = first.right { queueB.append(right) nextLevelCount += 1 }
if toBePrint == 0 { result.append(temp) queue = queueB temp = Array(repeating: 0, count: nextLevelCount)
toBePrint = nextLevelCount nextLevelCount = 0 queueB = [] flag.toggle() } }
return result}