102. 二叉树的层序遍历

题目描述

给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。

自己想到的笨方法

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public var val: Int
 *     public var left: TreeNode?
 *     public var right: TreeNode?
 *     public init() { self.val = 0; self.left = nil; self.right = nil; }
 *     public init(_ val: Int) { self.val = val; self.left = nil; self.right = nil; }
 *     public init(_ val: Int, _ left: TreeNode?, _ right: TreeNode?) {
 *         self.val = val
 *         self.left = left
 *         self.right = right
 *     }
 * }
 */
class Solution {
    func levelOrder(_ root: TreeNode?) -> [[Int]] {
        var ret = [[Int]]()
        guard let root = root else {
            return ret
        }
        var elementRet = [Int]()
        var enumQueue: [TreeNode] = [root]
        var waittingQueue = [TreeNode]()
        while !enumQueue.isEmpty {
            let first = enumQueue.removeFirst()
            elementRet.append(first.val)
            if let left = first.left {
                waittingQueue.append(left)
            }
            if let right = first.right {
                waittingQueue.append(right)
            }
            if enumQueue.isEmpty {
                ret.append(elementRet)
                elementRet.removeAll()
                enumQueue.append(contentsOf: waittingQueue)
                waittingQueue.removeAll()
            }
        }
        return ret
    }
}

更优的解法

要实现二叉树的层序遍历，可以使用广度优先搜索（BFS）算法。通过逐层遍历树的节点，可以按照从上到下、从左到右的顺序获取所有节点的值。

具体步骤如下：

1. 如果树为空，返回空列表。
2. 使用一个队列进行层次遍历，首先将根节点入队。
3. 初始化一个结果列表。
4. 当队列不为空时，遍历当前层的所有节点，并将这些节点的值存入当前层的列表中，然后将它们的子节点（如果有）加入队列。
5. 将当前层的列表加入结果列表中。
6. 返回结果列表。

以下是完整的 Swift 代码实现：

class Solution {
    func levelOrder(_ root: TreeNode?) -> [[Int]] {
        // 如果根节点是 nil，返回空列表
        guard let root = root else {
            return []
        }
        
        var result: [[Int]] = []
        var queue: [TreeNode] = [root]
        
        // 当队列不为空时，进行层次遍历
        while !queue.isEmpty {
            var level: [Int] = []
            let levelSize = queue.count
            
            // 遍历当前层的所有节点
            for _ in 0..<levelSize {
                let currentNode = queue.removeFirst()
                level.append(currentNode.val)
                
                // 将当前节点的左子节点加入队列（如果有的话）
                if let leftChild = currentNode.left {
                    queue.append(leftChild)
                }
                
                // 将当前节点的右子节点加入队列（如果有的话）
                if let rightChild = currentNode.right {
                    queue.append(rightChild)
                }
            }
            
            // 将当前层的列表加入结果列表中
            result.append(level)
        }
        
        return result
    }
}

解释：

• 初始化：如果树为空（即 root == nil），返回空列表 []。
• 广度优先搜索（BFS）：使用一个队列 queue 进行层次遍历，初始时将根节点入队。
• 层次遍历：当队列不为空时，进行层次遍历。记录当前层的节点数 levelSize，遍历当前层的所有节点，将它们的值存入 level 列表中，然后将它们的子节点（如果有）加入队列。
• 更新结果：每遍历完一层，将当前层的值列表 level 加入结果列表 result 中。
• 返回结果：最终返回结果列表 result，其中包含了每一层的节点值。