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

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

思路

一种是使用先序遍历来递归遍历所有节点，记录节点值和层数，然后按照层数进行输出
另一种是使用队列进行广度优先搜索：
每pop一次节点，就把该节点的左右子节点（如果有的话)放在队列后面。这样可以保证每一层的节点在队列中是紧挨着的
由于广度优先搜索不涉及递归操作，所以时间节省了很多

代码

我的傻瓜方法

/**
 * 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:
    vector<int> nums;
    vector<int> layers;
    void recur(TreeNode* root,int layer)
    {
        if(root==NULL)
            return;
        nums.push_back(root->val);
        layers.push_back(layer);

        recur(root->left,layer+1);
        recur(root->right,layer+1);

    }
    vector<int> levelOrder(TreeNode* root) {
        recur(root,1);
        int max=0;
        for(int i=0;i<layers.size();i++)
        {
            if(layers[i]>max)
                max=layers[i];
        }
        vector<int> res;

        for(int i=1;i<=max;i++)
        {
            for(int j=0;j<layers.size();j++)
            {
                if(layers[j]==i)
                    res.push_back(nums[j]);
            }
        }
        return res;
    }
};

根据大佬的思路改编的广度优先搜索

/**
 * 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:

    vector<int> levelOrder(TreeNode* root) {
        vector<int> res;
        if(root==NULL)
            return res;

        queue<TreeNode*> bfs;
        bfs.push(root);

        while(!bfs.empty())
        {
            TreeNode * node=bfs.front();
            bfs.pop();
            res.push_back(node->val);

            if(node->left!=NULL)
            {
                bfs.push(node->left);
            }
            if(node->right!=NULL)
            {
                bfs.push(node->right);
            }
        }
        return res;
    }
};