剑指 Offer 32 - II. 从上到下打印二叉树 II

关注

已于 2022-05-16 15:30:12 修改 · 223 阅读

原创 ·

本内容遵循 CC 4.0 BY-SA 版权协议

sysrepo 开发者指南（一个基于libyang与支持rpc的数据库） sysrepo 开发者指南（一个基于libyang与支持rpc的数据库）日志记录默认情况下，所有 Sysrepo 日志记录都处于关闭状态。如果启用，日志消息有 3 种输出。它们可以写入stderr、由处理syslog或简单地传递给回调。请务必注意，启用 Sysrepo 日志记录也会修改libyang日志记录设置。错误消息被视为标准 Sysrepo 错误，其他严重性较低的消息完全隐藏。要更改此行为，只需在启用 Sysrepo 日志记录后调整libyang日志记录设置。此外，几乎每个 Sysrepo 阅读详情

题目链接：力扣

我的代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int _level(TreeNode* root)
    {
        if(root == NULL)
            return 0;
        int h1 = _level(root->left);
        int h2 = _level(root->right);
        return h1 > h2 ? h1 + 1 : h2 + 1;
    }
    void _levelOrder(TreeNode* root,vector<vector<int>>& vv, int index)
    {
        if(root == NULL)
        {
            return;
        }
        vv[index].push_back(root->val);
        _levelOrder(root->left, vv, index + 1);
        _levelOrder(root->right, vv, index + 1);

    }
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> vv;
        if(root == NULL)
            return vv;
        int i = 0;
        //计算二叉树的深度
        int h = _level(root);
        vv.resize(h);
        _levelOrder(root, vv, i);
     
        return vv;
    }
};

整体思路很简单，为了知道返回顺序表的大小，先遍历一遍二叉树，算出二叉树的深度，然后再扩容，然后再遍历一遍二叉树，进行广度优先搜索将数据放进顺序表中。

这是我最开始想到的思路，这种写法有很多的缺点：

最明显的缺点是：

两次遍历二叉树都使用的是递归方法，如果二叉树层数过多，递归层数太深，很容易爆栈

看了官方的代码这种对比更加明显

class Solution {
public:
vector<vector<int>> levelOrder(TreeNode* root) {
vector <vector <int>> ret;
if (!root) {
return ret;
}

queue <TreeNode*> q;
q.push(root);
while (!q.empty()) {
int currentLevelSize = q.size();
ret.push_back(vector <int> ());
for (int i = 1; i <= currentLevelSize; ++i) {
auto node = q.front(); q.pop();
ret.back().push_back(node->val);
if (node->left) q.push(node->left);
if (node->right) q.push(node->right);
}
}

return ret;
}
};

官方写法借助了队列的性质，将每一层的数据分别入队列，等待下一层循环时将数据顺序表，而且 ret.push_back(vector <int> ());这一句代码我感觉很赞，这样可以避免像我一样先算出二叉树的深度，一次遍历二叉树就是O（N）的时间消耗，而且，这种方法用的是循环的方法，避免了函数调用的时间消耗，而且的循环没有递归层数太多栈溢出的可能。