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

## 前言

二叉树的常规便利： `前序遍历` 、 `中序遍历` 、 `后序遍历` 可能都已经非常熟悉了。

本文将结合一个题目的三种形态来玩一下花式遍历。

## 一、 顺序打印

### 1.1 题目

从上到下打印出二叉树的每个节点，同一层的节点按照从左到右的顺序打印。

例如:

给定二叉树: \[3,9,20,null,null,15,7],

```
     3
    / \
   9  20
     /  \
    15   7
```

返回：

```
[3,9,20,15,7]
```

提示：

节点总数 <= 1000

来源：[力扣（LeetCode）](https://leetcode-cn.com/problems/cong-shang-dao-xia-da-yin-er-cha-shu-lcof)

### 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 编码

```swift
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](https://4193904735-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-MI8JgbGh3U6X_oedqkm%2Fsync%2F03d580044eccdac9c334d91b6ee5a9fa02906a3b.png?generation=1630498065399761\&alt=media)

## 二、 逐行打印

### 2.1 题目

从上到下按层打印二叉树，同一层的节点按从左到右的顺序打印，每一层打印到一行。

例如:

给定二叉树: \[3,9,20,null,null,15,7],

```
     3
    / \
   9  20
     /  \
    15   7
```

返回其层次遍历结果：

```
 [
   [3],
   [9,20],
   [15,7]
 ]
```

### 2.2 分析

在第一种遍历的基础上，这本题加上了换行的逻辑。我们只需要加上换行的判断逻辑就可以了。

### 2.3 题解

```swift
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](https://4193904735-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-MI8JgbGh3U6X_oedqkm%2Fsync%2Fde0c0101e95fdf006a0a081d63aacf25184469ff.png?generation=1630498066054168\&alt=media)

## 三、 之字形打印

### 3.1 题目

请实现一个函数按照之字形顺序打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右到左的顺序打印，第三行再按照从左到右的顺序打印，其他行以此类推。

例如:

给定二叉树: \[3,9,20,null,null,15,7],

```
     3
    / \
   9  20
     /  \
    15   7
```

返回其层次遍历结果：

```
 [
   [3],
   [20,9],
   [15,7]
 ]
```

### 3.2 易错点

本题很容易想当然的觉得和第二种差不多，`左右`换成`右左`就可以了嘛～于是稍微改一改就写出下面的代码：

```swift
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](https://4193904735-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-MI8JgbGh3U6X_oedqkm%2Fsync%2F2e327c4c57ab48f1e12908f5cc95dd7e9d0ff27d.png?generation=1630498071147168\&alt=media)

### 3.3 分析

这里不将思维局限于遍历的方向。这里还是按顺序逐层便利。一个队列A存放当前行，一个队列B存放下一行的。当一行遍历完，将B赋值给A，再用B来存放下一行。而打印结果则根据当前行的方向决定是从头插入还是从末尾插入。

### 3.4 题解

```swift
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](https://4193904735-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-MI8JgbGh3U6X_oedqkm%2Fsync%2F1a7b6702069b4851345c450cd5ccce5f94310fa6.png?generation=1630498067689588\&alt=media)