【剑指offer】26.把二叉树打印成多行

总目录：

算法之旅导航目录

 

1.问题描述

给定一个节点数为 n 二叉树，要求从上到下按层打印二叉树的 val 值，同一层结点从左至右输出，每一层输出一行，将输出的结果存放到一个二维数组中返回。

例如：
给定的二叉树是{1,2,3,#,#,4,5} 

该二叉树多行打印层序遍历的结果是

[

[1],

[2,3],

[4,5]

]

数据范围：二叉树的节点数 0≤n≤1000，0≤val≤1000

要求：空间复杂度 O(n)，时间复杂度 O(n)

 

2.问题分析

本体难度还不如之字形打印。。。

 1广度优先搜索，或者叫层序迭代

使用队列，每次迭代开始时队列的长度就是当前层节点的数量，将每个节点出队并将其子节点入队，对出队的节点展开处理

2递归

记录递归到了第几层

3.代码实例

广度优先搜索、层序迭代

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};
*/
class Solution {
  public:
    vector<vector<int>> Print(TreeNode* pRoot) {
        vector<vector<int>> ret;
        if (!pRoot) {
            return ret;
        }

        queue<TreeNode*> pQ;
        pQ.push(pRoot);

        int curTreeLevel = 0;
        int nodeNumInLevel = 0;
        while (!pQ.empty()) {
            //准备空间
            ret.push_back(vector<int>{});
            nodeNumInLevel = pQ.size();

            //逐个取出当前层的节点，并压入下层的节点
            for (int i = 0; i < nodeNumInLevel; i++) {                
                auto* pCur = pQ.front();
                pQ.pop();

                ret[curTreeLevel].push_back(pCur->val);

                //压入下层节点
                if(pCur->left){
                    pQ.push(pCur->left);
                }
                if(pCur->right){
                    pQ.push(pCur->right);
                }
            }

            //层序改变
            curTreeLevel++;
        }

        return ret;
    }
};

 递归，标注层号

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};
*/
class Solution {
  public:
    void recurve(TreeNode* root, vector<vector<int>>& ret, int levelIndex) {
        //中止条件
        if (!root) {
            return;
        }

        //本层逻辑
        //尚无本层buffer
        while (ret.size() < levelIndex) {
            ret.push_back(vector<int> {});
        }
        //将本节点数值存入指定层
        ret[levelIndex - 1].push_back(root->val);

        //递归调用
        recurve(root->left, ret, levelIndex + 1);
        recurve(root->right, ret, levelIndex + 1);
    }

    vector<vector<int>> Print(TreeNode* pRoot) {
        vector<vector<int>> ret;
        if (!pRoot) {
            return ret;
        }

        recurve(pRoot, ret, 1);

        return ret;
    }
};