剑指 offer32（一、二、三）

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

思路：

利用双端队列，每次从双端队列的队头取出节点，如果该节点存在左子树和右子树，则加入队尾。

 vector<int> levelOrder(TreeNode* root) {
        if(root==nullptr)
            return {};
        vector<int>res;
        deque<TreeNode*>dequeTreeNode;
        dequeTreeNode.push_back(root);
        while(dequeTreeNode.size())
        {
            TreeNode*pre=dequeTreeNode.front();
            dequeTreeNode.pop_front();
            res.push_back(pre->val);
            if(pre->left)
                dequeTreeNode.push_back(pre->left);
            if(pre->right)
                dequeTreeNode.push_back(pre->right);
        }
        return res;

    }

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

BFS：

vector<vector<int>> levelOrder(TreeNode* root) {
        if(root== nullptr)
            return {};
        vector<vector<int>>res;
        queue<TreeNode*>nodes;
        nodes.push(root);
        while(!nodes.empty())
        {
            vector<int>tmp;
            for(int i=nodes.size();i>0;i--){
                TreeNode *node=nodes.front();
                nodes.pop();
                tmp.push_back(node->val);
                if(node->left!= nullptr) {
                    nodes.push(node->left);
                }
                if(node->right!= nullptr){
                    nodes.push(node->right);
                }
            }
            res.push_back(tmp);
        }
        return res;
    }

DFS：

void dfs(TreeNode*root,vector<vector<int>>&res,int level)
{
    if(!root)
        return;
    if(level>=res.size())
        res.emplace_back(vector<int>());
    res[level].emplace_back(root->val);
    dfs(root->left,res,level+1);
    dfs(root->right,res,level+1);
}
vector<vector<int>> levelOrder(TreeNode* root) {
    vector<vector<int>>res;
    dfs(root,res,0);
    return res;
}

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

vector<vector<int>> levelOrder(TreeNode* root) {
vector<vector<int>>res;
    if(root== nullptr)
        return res;
    bool flag=true;
    deque<TreeNode*>q;
    q.push_back(root);
    while(!q.empty())
    {
        int n=q.size();
        vector<int>out;
        TreeNode*node;
        while(n>0){
            if(flag)
            {
                node=q.front();
                q.pop_front();
                if(node->left)
                    q.push_back(node->left);
                if(node->right)
                    q.push_back(node->right);
            }else{
                node=q.back();
                q.pop_back();
                if(node->left)
                    q.push_front(node->left);
                if(node->right)
                    q.push_front(node->right);
            }
            out.push_back(node->val);
            n--;
        }
        flag=!flag;
        res.push_back(out);
    }
    return res;

}