前言
二叉树的常规便利： 前序遍历 、 中序遍历 、 后序遍历 可能都已经非常熟悉了。
本文将结合一个题目的三种形态来玩一下花式遍历。
一、 顺序打印
1.1 题目
从上到下打印出二叉树的每个节点，同一层的节点按照从左到右的顺序打印。
例如:
给定二叉树: [3,9,20,null,null,15,7],
返回：
提示：
节点总数 <= 1000
来源：力扣（LeetCode）
1.2 分析
由于二叉树并非一个有序队列，但题目要求我们有序的输出。此时可以考虑借助一个辅助队列进行解题。
通过分析我们可以找到规律：每次打印一个节点的时候，如果该节点存在子节点，则把该节点的子节点插入队列末尾。接下来从队列头部取出节点重复打印操作。直至所有节点打印完成。
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]
]
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],
[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
}
