按之字形顺序打印二叉树（剑指offer+队栈的应用）

按之字形顺序打印二叉树

• 参与人数：703时间限制：1秒空间限制：32768K
• 通过比例：25.31%
• 最佳记录：0 ms|8552K（  ）

题目描述

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

题意：看测试用例

测试用例:
{8,6,10,5,7,9,11}
对应输出应该为:
[[8],[10,6],[5,7,9,11]]

思路：用一个布尔量控制从左到右还是从右到左的顺序；先放入栈中，然后把他的左右孩子按照从左到右（或者从右向左）的顺序放入队中，按照本行的读取顺序；当本行结束之后，再把队中的数据放入栈中。就ok了

链接：http://www.nowcoder.com/practice/91b69814117f4e8097390d107d2efbe0?rp=3&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking

/**
题目描述

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

*/
#include<cstdio>
#include<stack>
#include<queue>
#include<vector>
using namespace std;

struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};
TreeNode *root;

class Solution {
public:
    vector<vector<int> > Print(TreeNode* pRoot) {
        vector<vector<int> >ans;
        if(pRoot==NULL) return ans;

        vector<int> arr;

        queue<TreeNode*> T;
        stack<TreeNode*> S;
        bool bo=true;   //用来记录，当前是从左向右还是从右向左
        int cnt=1;
        S.push(pRoot);

        while(!S.empty())
        {
            int tmp=0;
            TreeNode* p=S.top();
            S.pop();
            arr.push_back(p->val);
            TreeNode *left=p->left;
            TreeNode *right=p->right;
            cnt--;

            if(bo)
            {
                if(left!=NULL){T.push(left);}
                if(right!=NULL){T.push(right);}
            }
            else
            {
                if(right!=NULL){T.push(right);}
                if(left!=NULL){T.push(left);}
            }

            if(cnt==0)//一行结束
            {
                bo=!bo;
                ans.push_back(arr);
                arr.clear();
                while(!T.empty())
                {
                    TreeNode* q=T.front();
                    T.pop();
                    S.push(q);
                    cnt++;
                }
            }
        }
        return ans;
    }

};
TreeNode *Creat(int *pre,int *in,int n)
{
    TreeNode *s;
    for(int i=0;i<n;i++)
    {
        if(pre[0]==in[i])
        {
            s=new TreeNode(in[i]);
            //中序历遍中在根节点左边的都是左子树上的
            s->left=Creat(pre+1,in,i);
            //在根节点右边的，都是右子树上的，右子树需要从i+1开始
            s->right=Creat(pre+i+1,in+i+1,n-i-1);
            return s;
        }
    }
    return NULL;
}
int main()
{
    Solution so;
    int n;
    while(scanf("%d",&n)!=EOF)
    {
        root=NULL;
        int a[2005],b[2005];
        for(int i=0;i<n;i++)
            scanf("%d",&a[i]);
        for(int i=0;i<n;i++)
            scanf("%d",&b[i]);
        root=Creat(a,b,n);
        vector<vector<int> >ans=so.Print(root);
        for(int i=0;i<ans.size();i++)
        {
            for(int j=0;j<ans[i].size();j++)
            {
                printf("%d ",ans[i][j]);
            }
            printf("\n");
        }
    }

    return 0;
}

/*
7
8 6 5 7 10 9 11
5 6 7 8 9 10 11
测试用例:
{8,6,10,5,7,9,11}

对应输出应该为:
[[8],[10,6],[5,7,9,11]]
*/