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

题目链接：力扣

 

 我的代码：

/**
 * 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）的时间消耗，而且，这种方法用的是循环的方法，避免了函数调用的时间消耗，而且的循环没有递归层数太多栈溢出的可能。