LeetCode 107 Binary Tree Level Order Traversal II（二叉树的层级顺序遍历2）（*）

翻译

给定一个二叉树，返回从下往上遍历经过的每一个节点的值。

从左往右，从叶子到节点。

比如：
给定的二叉树是 {3,9,20,#,#,15,7}，
    3
   / 
  9  20
    /  
   15   7
返回它从下往上的遍历结果：
[
  [15,7],
  [9,20],
  [3]
]

原文

Given a binary tree, return the bottom-up level order traversal of its nodes' values. 

(ie, from left to right, level by level from leaf to root).

For example:
Given binary tree {3,9,20,#,#,15,7},
    3
   / 
  9  20
    /  
   15   7
return its bottom-up level order traversal as:
[
  [15,7],
  [9,20],
  [3]
]

分析

事实上吧，无论是从上到下还是从下到上都无所谓啦。最后反转一下就好了，关键还是在于怎样去遍历。

我一開始没理解好题意。结果是按节点以下的两个叶子来加入到vector的，后来发现原来是应该按层级。

所以採用了先进先出的队列，队列里要包括二叉树的层级信息。所以构造一个pair。

vector<vector<int>> vecAns;
if (!root) return vecAns;
queue<pair<int, TreeNode*>> queueTree;

首先定义了用于最后返回的vecAns，而后推断root是否为空，是的话直接返回不做加入操作。构造的queue中int用于存放层级信息，TreeNode*用于存放节点。

接下来定义了map。它的优势在于能够随时指定键来加入值，这里就是指定层级来加入信息，后面的是vector就是用于存放树节点的。root的层级设定为0。后面用make_pair来构造pair对。最后加入到queue中。

map<int, vector<int>> mapAns;
int rootLevel = 0;
queueTree.push(make_pair(rootLevel, root));

仅仅要queue不为空就一直循环。

每次一開始就解析出当前队列顶部的层级信息以及当前节点。将它加入到map中。加入完之后就能够弹出了。继续推断左右子树，假设为空就先加入到queue中等待下一部操作。待到下一次循环时，就是将它们加入到map中了。

while (!queueTree.empty()) {
    int currentLevel = (queueTree.front().first);
    TreeNode *currentNode = (queueTree.front().second);
    mapAns[currentLevel].push_back(currentNode->val);
    queueTree.pop();
    if (currentNode->left != NULL)
        queueTree.push(make_pair(currentLevel + 1, currentNode->left));
    if (currentNode->right != NULL)
        queueTree.push(make_pair(currentLevel + 1, currentNode->right));
}

将map中的信息逐个push到vector里，最后就直接return了。

for (auto iter = mapAns.rbegin(); iter != mapAns.rend(); ++iter) {
    vecAns.push_back(iter->second);
}
return vecAns;

Ok，大家能够去看看上一题：

LeetCode 102 Binary Tree Level Order Traversal（二叉树的层级顺序遍历）（*）

代码

/**
* Definition for a binary tree node.
* 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) {
        vector<vector<int>> vecAns;
        if (!root) return vecAns;
        queue<pair<int, TreeNode*>> queueTree;
        map<int, vector<int>> mapAns;
        int rootLevel = 0;
        queueTree.push(make_pair(rootLevel, root));
        while (!queueTree.empty()) {
            int currentLevel = (queueTree.front().first);
            TreeNode *currentNode = (queueTree.front().second);
            mapAns[currentLevel].push_back(currentNode->val);
            queueTree.pop();
            if (currentNode->left != NULL)
                queueTree.push(make_pair(currentLevel + 1, currentNode->left));
            if (currentNode->right != NULL)
                queueTree.push(make_pair(currentLevel + 1, currentNode->right));
        }
        for (auto iter = mapAns.rbegin(); iter != mapAns.rend(); ++iter) {
            vecAns.push_back(iter->second);
        }
        return vecAns;
    }
};