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

(1) 从上到下打印出二叉树的每个节点，同一层的节点按照从左到右的顺序打印。

分析：层序遍历

class Solution {
public:
    vector<int> levelOrder(TreeNode* root) {
        vector<int> res;
        if(root==nullptr) return res;
        queue<TreeNode*> que;
        que.push(root);
        while(!que.empty()){
            TreeNode* head = que.front();
            que.pop();
            res.push_back(head->val);
            if(head->left)que.push(head->left);
            if(head->right)que.push(head->right);
        }
        return res;

    }
};

---

(2) 从上到下按层打印二叉树，同一层的节点按从左到右的顺序打印，每一层打印到一行。

 分析：层序遍历，在上一题的基础上，使用辅助容器，保持每一层放置在一起

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> res;
        if(root==nullptr)return res;
        queue<TreeNode*> que;
        que.push(root);
        while(!que.empty()){
            vector<int> tmp;
            int len = que.size();
            for(int i =0;i<len;i++){
                TreeNode* head = que.front();
                que.pop();
                tmp.push_back(head->val);
                if(head->left)que.push(head->left);
                if(head->right)que.push(head->right);
            }
            res.push_back(tmp);
        }
        return res;
    }
};

(3) 请实现一个函数按照之字形顺序打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右到左的顺序打印，第三行再按照从左到右的顺序打印，其他行以此类推。

 分析：层序遍历，采用和上一题类似的策略，只是本题需要考虑，奇偶行的问题

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> res;
        if(root==nullptr){
            return res;
        }
        queue<TreeNode*> que;
        que.push(root);
        while(!que.empty()){
            vector<int> tmp;
            int len = que.size();//如果不提前保存的话，会因为que.size()是动态变化的而出错
            for(int i=0;i<len;i++){
                TreeNode* head = que.front();
                que.pop();
                tmp.push_back(head->val);
                if(head->left!=nullptr){
                    que.push(head->left);
                }
                if(head->right!=nullptr){
                    que.push(head->right);
                }
            }
            //奇数颠倒顺序
            if(res.size() % 2 == 1){
                reverse(tmp.begin(),tmp.end());
            }
            res.push_back(tmp);
        }
        return res;
    }
};

使用一个flag来标记层数 ，效率更高，注意初始划容器

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> ans;
        if (root == nullptr) return ans;
        queue<TreeNode*> que;
        que.push(root);
        int flag = 1;
        while (!que.empty()) {
            int len = que.size();
            vector<int> tmp(len);
            for (int i = 0; i < len; i++) {
                TreeNode* p = que.front();
                que.pop();
                if (flag %2!= 0) tmp[i] = p->val;
                else tmp[len - i - 1] = p->val;
                if (p->left) que.push(p->left);
                if (p->right) que.push(p->right);
            }
            //flag *= -1;
            flag+=1;
            ans.push_back(tmp);
        }
        return ans;
    }
};