LeetCode: Binary Tree Level Order Traversal II

跟1基本一样，就是用个stack就解决了，算一次过吧

 1 /**
 2  * Definition for binary tree
 3  * struct TreeNode {
 4  *     int val;
 5  *     TreeNode *left;
 6  *     TreeNode *right;
 7  *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 8  * };
 9  */
10 class Solution {
11 public:
12     void dfs(queue<TreeNode *> &pre, stack<vector<int>> &save) {
13         queue<TreeNode *> S;
14         vector<int> level;
15         while (!pre.empty()) {
16             TreeNode *tmp = pre.front();
17             if (tmp->left) S.push(tmp->left);
18             if (tmp->right) S.push(tmp->right);
19             level.push_back(tmp->val);
20             pre.pop();
21         }
22         save.push(level);
23         if (!S.empty()) {
24             pre = S;
25             dfs(pre, save);
26         }
27     }
28     vector<vector<int> > levelOrderBottom(TreeNode *root) {
29         // Start typing your C/C++ solution below
30         // DO NOT write int main() function
31         stack<vector<int>> save;
32         queue<TreeNode *> pre;
33         vector<vector<int>> ret;
34         if (!root) return ret;
35         pre.push(root);
36         dfs(pre, save);
37         while (!save.empty()) {
38             vector<int> tmp = save.top();
39             ret.push_back(tmp);
40             save.pop();
41         }
42         return ret;
43     }
44 };

后来写了个更好的代码

 1 /**
 2  * Definition for binary tree
 3  * struct TreeNode {
 4  *     int val;
 5  *     TreeNode *left;
 6  *     TreeNode *right;
 7  *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 8  * };
 9  */
10 class Solution {
11 public:
12     vector<vector<int> > levelOrderBottom(TreeNode *root) {
13         // Start typing your C/C++ solution below
14         // DO NOT write int main() function
15         vector<vector<int> > ret;
16         if (!root) return ret;
17         vector<int> cur;
18         queue<TreeNode *> S, T;
19         S.push(root);
20         while (!S.empty()) {
21             cur.clear();
22             while (!S.empty()) {
23                 TreeNode *tmp = S.front();
24                 S.pop();
25                 cur.push_back(tmp->val);
26                 if (tmp->left) T.push(tmp->left);
27                 if (tmp->right) T.push(tmp->right);
28             }
29             ret.push_back(cur);
30             S.swap(T);
31         }
32         reverse(ret.begin(), ret.end());
33         return ret;
34     }
35 };

再加个recursive的方法

 1 /**
 2  * Definition for binary tree
 3  * struct TreeNode {
 4  *     int val;
 5  *     TreeNode *left;
 6  *     TreeNode *right;
 7  *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 8  * };
 9  */
10 class Solution {
11 private:
12     vector<vector<int> > res;
13 public:
14     void dfs(TreeNode *root, int d) {
15         if (!root) return;
16         if (d >= res.size()) res.push_back(vector<int>(0));
17         res[d].push_back(root->val);
18         dfs(root->left, d+1);
19         dfs(root->right, d+1);
20     }
21     vector<vector<int> > levelOrderBottom(TreeNode *root) {
22         // IMPORTANT: Please reset any member data you declared, as
23         // the same Solution instance will be reused for each test case.
24         res.clear();
25         dfs(root, 0);
26         for (int i = 0; i < res.size()/2; i++) swap(res[i], res[res.size()-1-i]);
27         return res;
28     }
29 };

C#:

 1 /**
 2  * Definition for a binary tree node.
 3  * public class TreeNode {
 4  *     public int val;
 5  *     public TreeNode left;
 6  *     public TreeNode right;
 7  *     public TreeNode(int x) { val = x; }
 8  * }
 9  */
10 public class Solution {
11     public List<List<int>> LevelOrderBottom(TreeNode root) {
12         List<List<int>> ans = new List<List<int>>();
13         if (root == null) return ans;
14         List<int> tmp = new List<int>();
15         Queue<TreeNode> que = new Queue<TreeNode>();
16         que.Enqueue(root);
17         que.Enqueue(null);
18         while (true)
19         {
20             TreeNode peek = que.Peek();
21             que.Dequeue();
22             if (peek == null)
23             {
24                 ans.Add(tmp);
25                 if (que.Count == 0 || que.Peek() == null) break;
26                 tmp = new List<int>();
27                 que.Enqueue(null);
28             }
29             else {
30                 if (peek.left != null) que.Enqueue(peek.left);
31                 if (peek.right != null) que.Enqueue(peek.right);
32                 tmp.Add(peek.val);
33             }
34         }
35         ans.Reverse();
36         return ans;
37     }
38 }

View Code