打印二叉树题型：从上到下打印，打印为为多行以及按之字形打印为多行

打印二叉树题目：

1）从上到下打印出二叉树的每个节点，同一层的结点按照从左至右的顺序打印。如上图，打印结果则为1,2,3,4,5,6

这种层次遍历可以如下分析：

首先要打印根节点，打印之前要保存其左孩子2，和右孩子结点3。下一步打印左结点2，同样保存其左右孩子节点。

可以发现这是一个类似于队列，先进先出的结构。

用队列实现，每次一个结点要出队，则其左右孩子入队。

code如下：

/*
struct TreeNode {
	int val;
	struct TreeNode *left;
	struct TreeNode *right;
	TreeNode(int x) :
			val(x), left(NULL), right(NULL) {
	}
};*/
class Solution {
public:
    vector<int> PrintFromTopToBottom(TreeNode* root) {
        vector<int> res;
        if(root == nullptr) return res;
        queue<TreeNode*> que;
        que.push(root);
        while(!que.empty())
            {
            TreeNode* node = que.front();
            if(node->left){
            	que.push(node->left);
            }
            if(node->right){
                que.push(node->right);
            }
            res.push_back(node->val);
            que.pop();
        }
        return res;
    }
};

2）从上到下按层打印二叉树，同一层的结点按从左到右的顺序打印，每一层打印为一行。例如图中二叉树打印结果为：1

                                                                                                                                                                                             2,3

                                                                                                                                                                                             4,5,6

与1）类似，也可以用一个队列来保存将要打印的结点。为了把二叉树的每一行单独打印到一行里，需要两个变量：一个变量表示在当前层中还没有打印的节点数，另一个变量表示下一层结点的数目。

code:

/*
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) {
            if(pRoot == nullptr) return vector<vector<int>>();
            vector<vector<int>> res;
            queue<TreeNode*> que;
            que.push(pRoot);
            while(!que.empty()){
                int lo = 0;
                int hi = que.size();
                vector<int> vec;
                while(lo++<hi){
                    TreeNode* temp = que.front();
                	vec.push_back(temp->val);
                    que.pop();
                    if(temp->left) que.push(temp->left);
                    if(temp->right) que.push(temp->right);
                }
                res.push_back(vec);
            }
            return res;
        }
    
};

不管是广度优先遍历一幅有向图还是一棵树，都要用到队列。

3)按之字形打印。

即第一行按照从左到右的顺序打印，第二层按照从右到左的顺序打印，第三行再按照从左到右的顺序打印，其他依次类推。如上图二叉树的打印结果为：1

                                                                                                                                                                                                                                                 3,2

                                                                                                                                                                                                                                                 4,5,6

一个直观的想法是将2）中的结果，对第二行，第四行等翻转，得到结果。

code:

/解法1，偷懒做法：
//先将二叉树每层保存为一个vector，组成每行都是从左至右顺序的二维vector.
//然后用reverse对每奇数行翻转。
/*
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) {
        if(pRoot == nullptr) return vector<vector<int>>();
        vector<vector<int>> res;
        queue<TreeNode*> que;
        que.push(pRoot);
        while(!que.empty()){
            int lo = 0;
            int hi = que.size();
            vector<int> vec;
            while(lo++<hi){
                TreeNode* temp = que.front();
                vec.push_back(temp->val);
                que.pop();
                if(temp->left) que.push(temp->left);
                if(temp->right) que.push(temp->right);
            }
            res.push_back(vec);
        }
        int len = res.size();
        for(int i = 1; i<len; i = i+2){
            reverse(res[i].begin(), res[i].end());
        }
        return res;
    }
     
};

另一个精巧的思路： 使用两个栈。

分析：当根节点打印之后，其左右子节点先后保存到一个数据容器里，值得注意的是，打印第二层的节点时，先打印节点3，再打印节点2，看上去像是一个后进先出的过程。

使用两个栈。栈1保存根节点，栈2保存其左右子节点（左子节点先进）。这样打印的结果就是第二行先打印右子节点。

随后，栈1保存栈2出栈节点的右左子节点（右子节点先进），打印的结果就是第三行为从左至右打印。

后续以此类推。

code:

//解法2，使用两个栈
/*
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) {
        if(pRoot == nullptr) return vector<vector<int>>();
        stack<TreeNode*> s1;
        stack<TreeNode*> s2;
        vector<vector<int>> res;
        s1.push(pRoot);
        while(!s1.empty() || !s2.empty()){
            vector<int> vec;
            TreeNode* temp = new TreeNode(0);
            if(!s1.empty()){
                while(!s1.empty()){
                    temp = s1.top();
                    s1.pop();
                    vec.push_back(temp->val);
                    if(temp->left) s2.push(temp->left);
                    if(temp->right) s2.push(temp->right);
            	}
                res.push_back(vec);
            }
            else if(!s2.empty()){
                while(!s2.empty()){
                    temp = s2.top();
                    s2.pop();
                    vec.push_back(temp->val);
                    if(temp->right) s1.push(temp->right);
                    if(temp->left)  s1.push(temp->left);
                }
                res.push_back(vec);
            }
        }
        return res;
    }
};