剑指offer—day 6（二叉树—层序）

1.剑指 Offer 32 - I. 从上到下打印二叉树【中等】

从上到下打印出二叉树的每个节点，同一层的节点按照从左到右的顺序打印。
例如:
给定二叉树: [3,9,20,null,null,15,7],

    3
   / \
  9  20
    /  \
   15   7

返回：

[3,9,20,15,7]

vector<int> levelOrder(TreeNode* root) {  //层序遍历，队列
    vector<int> rec; 
    queue<TreeNode*> q;  //层序队列
    if(root!=NULL)       //判空
        q.push(root);
    while(!q.empty()){
        TreeNode* t=q.front();  //取队列头
        q.pop();
        rec.push_back(t->val);

        if(t->left!=NULL)       //左子入队
            q.push(t->left);
        if(t->right!=NULL)      //右子入队
            q.push(t->right);
    }
    return rec;
}

\qquad

2.剑指 Offer 32 - II. 从上到下打印二叉树 II【简单】

从上到下按层打印二叉树，同一层的节点按从左到右的顺序打印，每一层打印到一行。
例如:
给定二叉树: [3,9,20,null,null,15,7],

    3
   / \
  9  20
    /  \
   15   7

返回其层次遍历结果：

[
  [3],
  [9,20],
  [15,7]
]

思路：

对于层序遍历，每次将队列清空再出队，这样的话，每次队列里面都会存有某一行全部的结点。等到一行结点全部出队时，下一行结点也就全部入队了，循环往复，可以对每一层进行操作！

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> ());     //先压入一个空的vector数组
            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;
    }

\qquad

3.剑指 Offer 32 - III. 从上到下打印二叉树 III【中等】

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

例如:
给定二叉树: [3,9,20,null,null,15,7],

    3
   / \
  9  20
    /  \
   15   7

返回其层次遍历结果：

[
  [3],
  [20,9],
  [15,7]
]

思路：先创建二维数组，全部进队，然后对需要逆序的层，压入一维数组t，最后将t覆盖赋值回原来的二维数组即可。

vector<vector<int>> levelOrder(TreeNode* root) {
    vector<vector<int>> ret;
    queue<TreeNode*> q;
    if(!root)
        return ret;
    q.push(root);
    while(!q.empty()){
        int nowsize=q.size();  //目前大小
        ret.push_back(vector<int> ());
        for(int i=0;i<nowsize;i++){
            auto n=q.front();
            q.pop();
            ret.back().push_back(n->val);
            if(n->left!=NULL)
                q.push(n->left);
            if(n->right!=NULL)
                q.push(n->right);
        }
    }
    for(int i=1;i<ret.size();i=i+2){
        vector<int> t;
        while(!ret[i].empty()){
            auto temp=ret[i].back();
            t.push_back(temp);   //存储逆序的层
            ret[i].pop_back();   
        }
            
        ret[i]=t;   //正序之后再覆盖回去
    }
    return ret;
}