59按之字形顺序打印二叉树

题目描述

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

需要2个桟（后进先出）。
我们在打印某一行节点时，把下一层的子节点保存到相应的桟里。如果当前打印的是奇数层，则先保存左子树再保存右子树节点到
第一个桟里，如果当前打印的是偶数层，则先保存右子树再保存左子树节点。

 1 import java.util.ArrayList;
 2 import java.util.Stack;
 3 /*
 4 public class TreeNode {
 5     int val = 0;
 6     TreeNode left = null;
 7     TreeNode right = null;
 8 
 9     public TreeNode(int val) {
10         this.val = val;
11 
12     }
13 
14 }
15 */
16 public class Solution {
17     public ArrayList<ArrayList<Integer> > Print(TreeNode root) {
18         ArrayList<ArrayList<Integer>> res = new ArrayList<ArrayList<Integer>>();
19         Stack<TreeNode> stack1 = new Stack<TreeNode>();
20         Stack<TreeNode> stack2 = new Stack<TreeNode>();
21         int flag = 1;
22         stack1.push(root);
23         while(!stack1.empty()||!stack2.empty()){
24             if(flag==1){
25                 ArrayList<Integer> res_temp = new ArrayList<Integer>(); 
26                 while(!stack1.empty()){
27                     TreeNode resNode = stack1.pop();
28                     if(resNode !=null){
29                         res_temp.add(resNode.val);
30                         stack2.push(resNode.left);
31                         stack2.push(resNode.right);
32                     }
33                 }
34                 if(!res_temp.isEmpty())
35                     res.add(res_temp);
36                 flag = 1-flag;
37             }
38             else{
39                 ArrayList<Integer> res_temp = new ArrayList<Integer>(); 
40                 while(!stack2.empty()){
41                     TreeNode resNode = stack2.pop();
42                     if(resNode!=null){
43                         res_temp.add(resNode.val);
44                         stack1.push(resNode.right);
45                         stack1.push(resNode.left);
46                     }
47                 }
48                    if(!res_temp.isEmpty())
49                     res.add(res_temp);
50                  flag = 1-flag;
51             }
52         }
53         return res;
54     }
55 
56 }

 

 

c++:20180730

 

 1 /*
 2 struct TreeNode {
 3     int val;
 4     struct TreeNode *left;
 5     struct TreeNode *right;
 6     TreeNode(int x) :
 7             val(x), left(NULL), right(NULL) {
 8     }
 9 };
10 */
11 class Solution {
12 public:
13         vector<vector<int> > Print(TreeNode* pRoot) {
14 
15             vector<vector<int>> res ;
16             queue<TreeNode*> q;
17             if(pRoot==NULL) return res;
18             q.push(pRoot);
19             bool flag=true;
20             int size ;
21             while(!q.empty()){
22                 vector<int> temp ;
23                 size = q.size();
24 
25                 for(int i = 0;i<size;i++){
26                     TreeNode* root = q.front();
27                     q.pop();
28    
29                     if(root->left!=NULL) q.push(root->left);
30                     if(root->right!=NULL) q.push(root->right);
31                     
32                     if(flag)
33                         temp.push_back(root->val);
34                     else
35                         temp.insert(temp.begin(),root->val);
36                 }
37                 res.push_back(temp);
38                 flag=!flag;
39             }
40             return res;
41         }
42     
43 };

 

转载于:https://www.cnblogs.com/zle1992/p/8277596.html