Links

32.从上到下花式打印二叉树

前言

二叉树的常规便利: 前序遍历中序遍历后序遍历 可能都已经非常熟悉了。
本文将结合一个题目的三种形态来玩一下花式遍历。

一、 顺序打印

1.1 题目

从上到下打印出二叉树的每个节点,同一层的节点按照从左到右的顺序打印。
例如:
给定二叉树: [3,9,20,null,null,15,7],
3
/ \
9 20
/ \
15 7
返回:
[3,9,20,15,7]
提示:
节点总数 <= 1000

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
}
1

二、 逐行打印

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
}
2

三、 之字形打印

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
}
然后顺序就乱掉了:
4

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
}
3