牛客网－Ｃ++剑指offer－第五十八题(按之字形顺序打印二叉树)

题目描述

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

 

解题思路:

1.非递归的广度优先搜索是利用一个队列进行存储的，使得可以一层一层的打印。

2.题目要求使用使用之字形进行打印，考虑将二叉树分为奇数层和偶数层，奇数层从左往右打印，偶数层从右往左打印。使用两个栈结构进行奇数层和偶数层结点的分别存储，分别为s1,s2。(利用了栈的ＬＩＦＯ性质，如果使用两个队列，那么以下图为例，输出结果为Ｆ，ＥＣ，ＨＧＡＤ，ＭＢ。无法满足题目需求)

3.考虑到分层的问题，需要使用一个计数器，在奇数层操作时将下一层的数据存储到s2，并且计层，在偶数层操作时将下一层的数据存储到s１，并且计层，以此类推进行分层

参考代码:

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <stack>
#include <queue>
#include <list>
#include <unordered_map>

using namespace std;


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> > res;
        vector<int> temp;
        
        if (pRoot == NULL)
            return res;

        TreeNode *pMove = pRoot;
        stack<TreeNode *> odd_s; //奇数层用队列存
        stack<TreeNode *> even_s;//偶数层用栈存
        bool flag = false;       //false代表奇数层，true代表偶数层
        int odd_count = 1;       //奇数层计数
        int even_count = 0;       //偶数层计数

        odd_s.push(pRoot);//已经执行了第一层，奇数层
        while (!odd_s.empty() || !even_s.empty()) {
            //注意条件，odd_s不为空，否则下面pMove读取失败
            if (!flag && !odd_s.empty()) //偶数层操作
            {
                pMove = odd_s.top();
                odd_s.pop();
                temp.push_back(pMove->val);
                if (pMove->left)
                {
                    even_s.push(pMove->left);
                    ++even_count;
                }
                if (pMove->right)
                {
                    even_s.push(pMove->right);
                    ++even_count;
                }
                odd_count--;
                if (odd_count == 0)
                {
                    res.push_back(temp);
                    temp.clear();
                    flag = true;
                }
            }
            //注意条件，even_s不为空，否则下面pMove读取失败
            if (flag && !even_s.empty())     //奇数层操作
            {
                pMove = even_s.top();
                even_s.pop();
                temp.push_back(pMove->val);

                if (pMove->right)
                {
                    odd_s.push(pMove->right);
                    ++odd_count;
                }
                if (pMove->left)
                {
                    odd_s.push(pMove->left);
                    ++odd_count;
                }
                even_count--;
                if (even_count == 0)
                {
                    res.push_back(temp);
                    temp.clear();
                    flag = false;
                }
            }
        }
        return res;
    }
};
int main() {

    Solution solution;

    TreeNode TreeNode1(1);
    TreeNode TreeNode2(2);
    TreeNode TreeNode3(3);
    TreeNode TreeNode4(4);
    TreeNode TreeNode5(5);
    TreeNode TreeNode6(6);
    TreeNode TreeNode7(7);

    TreeNode1.left = &TreeNode2;
    TreeNode1.right = &TreeNode3;

    TreeNode2.left = &TreeNode4;
    TreeNode2.right = &TreeNode5;

    TreeNode3.left = &TreeNode6;
    TreeNode3.right = &TreeNode7;

    TreeNode4.left = NULL;
    TreeNode4.right = NULL;

    TreeNode5.left = NULL;
    TreeNode5.right = NULL;

    TreeNode6.left = NULL;
    TreeNode6.right = NULL;

    TreeNode7.left = NULL;
    TreeNode7.right = NULL;

    TreeNode* my_head = &TreeNode1;

    solution.Print(my_head);

    return 0;
}