LeetCode 102. Binary Tree Level Order Traversal（二叉树层序遍历）

leetcode.com/problems/bi…

Given the root of a binary tree, return the level order traversal of its nodes' values. (i.e., from left to right, level by level).

Example 1:

Input: root = [3,9,20,null,null,15,7]
Output: [[3],[9,20],[15,7]]

Example 2:

Input: root = [1]
Output: [[1]]

Example 3:

Input: root = []
Output: []

Constraints:

• The number of nodes in the tree is in the range [0, 2000].
• -1000 <= Node.val <= 1000

解法一：

BFS，广度优先搜索。层序遍历二叉树是典型的广度优先搜索 BFS 的应用，但是这里稍微复杂一点的是，如何判断此时已经是该层的末尾，我用了两个 queue，然后先把根节点放进去 queue1，这时候找根节点的左右两个子节点，把这两个子节点加到queue2，这时候去掉 queue1 的根节点，此时 queue2 里的元素就是下一层的所有节点，下次循环再将 queue2 所有元素的子节点存入 queue1，此时 queue1 的元素就是下一层的所有节点，以此类推，可以完成层序遍历，参见代码如下：

class Solution {
    fun levelOrder(root: TreeNode?): List<List<Int>> {
        if (root == null) {
            return mutableListOf()
        }
        val result: MutableList<List<Int>> = mutableListOf()
        val queue1: Queue<TreeNode> = ArrayDeque<TreeNode>()
        val queue2: Queue<TreeNode> = ArrayDeque<TreeNode>()

        queue1.offer(root)
        result.add(listOf(root.`val`))

        while (queue1.isNotEmpty() || queue2.isNotEmpty()) {
            if (queue1.isNotEmpty()) {
                queue1.forEach {
                    it.left?.let {
                        queue2.offer(it)
                    }
                    it.right?.let {
                        queue2.offer(it)
                    }
                }
                queue1.clear()
            } else if (queue2.isNotEmpty()) {
                queue2.forEach {
                    it.left?.let {
                        queue1.offer(it)
                    }
                    it.right?.let {
                        queue1.offer(it)
                    }
                }
                queue2.clear()
            }

            if (queue1.isEmpty() && queue2.isNotEmpty()) {
                val list: List<Int> = queue2.toList().map { it.`val` }
                result.add(list)
            } else if (queue2.isEmpty() && queue1.isNotEmpty()) {
                val list: List<Int> = queue1.toList().map { it.`val` }
                result.add(list)
            }
        }
        return result
    }
}

当然也可以只用一个 queue，每次循环拿到 queue 的长度 length，遍历前 length 个元素就是当前层的所有元素。

class Solution {
    fun levelOrder(root: TreeNode?): List<List<Int>> {
        if (root == null) {
            return mutableListOf()
        }
        val result: MutableList<List<Int>> = mutableListOf()
        val queue: Queue<TreeNode> = ArrayDeque<TreeNode>()

        queue.offer(root)

        while (queue.isNotEmpty()) {
            val length = queue.size
            val subResult = mutableListOf<Int>()
            for (index in 0 until length) {
                val currentNode = queue.poll()
                subResult.add(currentNode.`val`)
                currentNode.left?.let {
                    queue.offer(it)
                }
                currentNode.right?.let {
                    queue.offer(it)
                }
            }
            result.add(subResult)
        }
        return result
    }
}

解法二：

DFS，深度优先搜索。

class Solution {
    fun levelOrder(root: TreeNode?): List<List<Int>> {
        if (root == null) {
            return mutableListOf()
        }
        val result: MutableList<MutableList<Int>> = mutableListOf()
        dfs(root, result, 0)
        return result
    }

    private fun dfs(node: TreeNode?, result: MutableList<MutableList<Int>>, level: Int) {
        if (node == null) {
            return
        }
        if (result.size < level + 1) {
            result.add(mutableListOf())
        }
        result[level].add(node.`val`)
        dfs(node.left, result, level + 1)
        dfs(node.right, result, level + 1)
    }
}