LeetCode102. 二叉树的层序遍历

102. 二叉树的层序遍历

---

一、题目

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

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：[[3],[9,20],[15,7]]

示例 2：

输入：root = [1]
输出：[[1]]

示例 3：

输入：root = []
输出：[]

提示：

• 树中节点数目在范围 [0, 2000] 内
• -1000 <= Node.val <= 1000

二、题解

方法一：队列迭代

算法思路:

层序遍历二叉树的基本思想是从根节点开始,按层次顺序遍历整棵树。具体做法是使用队列来辅助进行层次遍历。

1. 首先将根节点入队。

2. 当队列不为空时,重复以下过程:

   • 从队列头部取出一个节点,访问该节点的值

   • 将该节点的左右子节点如果不为空则依次入队

   • 将该节点出队

3. 当队列为空时结束遍历

这样通过队列先进先出的特性,保证每次都是取出并访问当前这一层的节点,同层节点被顺序访问,不同层节点按层次顺序被访问,达到层序遍历的效果。

具体实现:

1. 定义一个队列que,用来存储待访问的节点

2. 判断根节点是否为空,如果不为空则将根节点入队

3. 定义一个结果列表result来存储每层节点的值

4. 当队列不为空时,进行如下操作:

   • 定义当前层级节点数size为队列大小,用于控制每层遍历次数

   • 循环size次,每次从队头取出一个节点:

     • 访问该节点,将值添加到vec中

     • 如果左右子节点不为空,则加入队列中等待下一层遍历

   • 将当前层级节点vec添加到result中

5. 返回结果列表result

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        queue<TreeNode*> que;
        if(root != NULL) que.push(root);
        vector<vector<int>> result;
        while(!que.empty()){
            vector<int> vec;
            int size = que.size();
            for(int i = 0; i < size; i++){
                TreeNode *node = que.front();
                que.pop();
                vec.push_back(node->val);
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
            result.push_back(vec);
        }
        return result;
    }
};

算法分析:

• 时间复杂度:O(N),N为二叉树节点数。需要遍历所有节点。

• 空间复杂度:O(N)。队列中最多会存放所有节点。

方法二：递归

算法思路:

递归实现层序遍历的基本思路是:

1. 定义一个递归函数,传入当前节点、结果列表、当前层数。

2. 在递归函数内,首先判断当前节点是否为空,为空则直接返回。

3. 接着判断结果列表的大小是否等于当前层数,如果等于,说明需要创建一个新vector来存储当前层的节点。

4. 然后将当前节点的值加入到结果列表对应的vector中,即加入到当前层中。

5. 最后递归调用当前节点的左右子节点,层数+1,开始处理下一层节点。

通过递归处理左右子节点,并传递层数,可以保证每次处理的是相同层的节点,从而实现层序遍历。

具体实现:

1. 定义递归函数order,包含当前节点、结果列表、层数作为参数。

2. 在order内部:

   • 判断当前节点是否为空,为空直接返回

   • 判断result大小是否等于depth,等于则在result创建新vector

   • 将当前节点值加入result对应层的vector中

   • 递归调用左右子节点,层数+1

3. 在main函数中:

   • 初始化result列表和depth变量

   • 从根节点调用递归函数order启动遍历

   • 返回result作为结果

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    void order(TreeNode *cur, vector<vector<int>>&result, int depth){
        if(cur == nullptr) return;
        if(depth == result.size()) result.push_back(vector<int> ());
        result[depth].push_back(cur->val);
        order(cur->left, result, depth+1);
        order(cur->right, result, depth+1);
    }
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> result;
        int depth = 0;
        order(root, result, depth);
        return result;
    }
};

算法分析:

• 时间复杂度 O(N):需要递归遍历树的所有节点。

• 空间复杂度 O(N):结果列表中存储每层的节点,最大为全树大小。

recursion通过传递层数、判断结果列表大小的方式巧妙地实现了层序遍历,虽然递归代码比较难以理解,但总体思路是清晰的。