【剑指offer】19.按之字形顺序打印二叉树

总目录：

算法之旅导航目录

 

1.问题描述

给定一个二叉树，返回该二叉树的之字形层序遍历，（第一层从左向右，下一层从右向左，一直这样交替）

数据范围：0≤n≤1500,树上每个节点的val满足 ∣val∣<=1500

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

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

 

2.问题分析

 1层序迭代、辅助队列，每层迭代时按从左到右的顺序存储下一层节点，而打印本层节点时需要注意是否从左到右

2递归，用一个二维vector去接收每一层的节点值，递归完成后再按规则翻转相应层

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*> nodeVec;//迭代存储每层节点
        int nodeNumInLevel = 0; //当前层节点数量
        bool isLeftToRight = true; //当前层的节点顺序
        TreeNode* pCur = NULL;//哨兵节点

        nodeVec.push(pRoot);
        while (!nodeVec.empty()) {
            //接受打印
            vector<int> curLevelVec;

            //逐个遍历当前层，存储节点
            nodeNumInLevel = nodeVec.size();//取出当前层节点的数量
            for (int i = 0; i < nodeNumInLevel; i++) {
                pCur = nodeVec.front();
                nodeVec.pop();

                //循序插入还是逆序
                if (isLeftToRight) {
                    curLevelVec.push_back(pCur->val);                    
                } else {
                    curLevelVec.insert(curLevelVec.cbegin(), pCur->val);
                }

                //按从左到右顺序存储下层节点
                if (pCur->left) nodeVec.push(pCur->left);
                if (pCur->right) nodeVec.push(pCur->right);
            }
            ret.push_back(curLevelVec);

            //翻转
            isLeftToRight = !isLeftToRight;
        }

        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>>& vec, int level) {
        //中止条件
        if (!root) {
            return;
        }

        //本层逻辑
        //本层buffer尚未建立
        if (vec.size() < level) {
            vec.push_back(vector<int> {});
        }
        vec[level - 1].push_back(root->val);

        //调用递归
        recurve(root->left, vec, level + 1);
        recurve(root->right, vec, level + 1);

    }

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

        //进入迭代,获得的是每层都从左到右的打印
        recurve(pRoot, bufferVec, 1);

        //new para
        vector<vector<int> > retVec;
        int levelNum = bufferVec.size();
        int nodeNumInLevel = 0;
        bool isLeftToRight = true;

        //按规则翻转
        for (int i = 0; i < levelNum; i++) {
            //新建vec
            retVec.push_back(vector<int> {});

            //获取元素数量
            nodeNumInLevel = bufferVec[i].size();
            for (int j = 0; j < nodeNumInLevel; j++) {
                if(isLeftToRight){
                    retVec[i].push_back(bufferVec[i][j]);                    
                }
                else{
                    retVec[i].insert(retVec[i].cbegin(),bufferVec[i][j]);
                }
            }
            isLeftToRight = !isLeftToRight;
        }
        return retVec;
    }
};