LeetCode: Binary Tree Level Order Traversal II

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

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    void dfs(queue<TreeNode *> &pre, stack<vector<int>> &save) {
        queue<TreeNode *> S;
        vector<int> level;
        while (!pre.empty()) {
            TreeNode *tmp = pre.front();
            if (tmp->left) S.push(tmp->left);
            if (tmp->right) S.push(tmp->right);
            level.push_back(tmp->val);
            pre.pop();
        }
        save.push(level);
        if (!S.empty()) {
            pre = S;
            dfs(pre, save);
        }
    }
    vector<vector<int> > levelOrderBottom(TreeNode *root) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        stack<vector<int>> save;
        queue<TreeNode *> pre;
        vector<vector<int>> ret;
        if (!root) return ret;
        pre.push(root);
        dfs(pre, save);
        while (!save.empty()) {
            vector<int> tmp = save.top();
            ret.push_back(tmp);
            save.pop();
        }
        return ret;
    }
};

 后来写了个更好的代码

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<vector<int> > levelOrderBottom(TreeNode *root) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        vector<vector<int> > ret;
        if (!root) return ret;
        vector<int> cur;
        queue<TreeNode *> S, T;
        S.push(root);
        while (!S.empty()) {
            cur.clear();
            while (!S.empty()) {
                TreeNode *tmp = S.front();
                S.pop();
                cur.push_back(tmp->val);
                if (tmp->left) T.push(tmp->left);
                if (tmp->right) T.push(tmp->right);
            }
            ret.push_back(cur);
            S.swap(T);
        }
        reverse(ret.begin(), ret.end());
        return ret;
    }
};

 再加个recursive的方法

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
private:
    vector<vector<int> > res;
public:
    void dfs(TreeNode *root, int d) {
        if (!root) return;
        if (d >= res.size()) res.push_back(vector<int>(0));
        res[d].push_back(root->val);
        dfs(root->left, d+1);
        dfs(root->right, d+1);
    }
    vector<vector<int> > levelOrderBottom(TreeNode *root) {
        // IMPORTANT: Please reset any member data you declared, as
        // the same Solution instance will be reused for each test case.
        res.clear();
        dfs(root, 0);
        for (int i = 0; i < res.size()/2; i++) swap(res[i], res[res.size()-1-i]);
        return res;
    }
};

 C#:

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public int val;
 *     public TreeNode left;
 *     public TreeNode right;
 *     public TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public List<List<int>> LevelOrderBottom(TreeNode root) {
        List<List<int>> ans = new List<List<int>>();
        if (root == null) return ans;
        List<int> tmp = new List<int>();
        Queue<TreeNode> que = new Queue<TreeNode>();
        que.Enqueue(root);
        que.Enqueue(null);
        while (true)
        {
            TreeNode peek = que.Peek();
            que.Dequeue();
            if (peek == null)
            {
                ans.Add(tmp);
                if (que.Count == 0 || que.Peek() == null) break;
                tmp = new List<int>();
                que.Enqueue(null);
            }
            else {
                if (peek.left != null) que.Enqueue(peek.left);
                if (peek.right != null) que.Enqueue(peek.right);
                tmp.Add(peek.val);
            }
        }
        ans.Reverse();
        return ans;
    }
}