LeetCode刷题笔记（Binary Tree Level Order Traversal II）

今天是清明节假期的最后一天了，趁着不忙赶紧刷了一道题，下面就和大家来分享一下经验吧！

题目如下：

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,null,null,15,7],
    3
   / \
  9  20
    /  \
   15   7
return its bottom-up level order traversal as:
[
  [15,7],
  [9,20],
  [3]
]

题意分析： 

给定一个二分搜索树，返回“自底向上”式广度优先遍历后节点的值。“自底向上”式广度优先遍历为一层一层的从左往右、从叶子到根节点遍历。

解答如下：

方法一（队列法）

与“https://blog.csdn.net/Vensmallzeng/article/details/88924863”中方法一的思路一样，只是改变了节点值的存储顺序而已。

class Solution{
public:
    vector<vector<int>> levelOrderBottom(TreeNode* root){
        vector<vector<int>> res;
        if ( !root )
            return res;
        queue< TreeNode* > q;
        q.push( root );
        while ( !q.empty() ){
            vector<int> level;                      //建立存放每一层节点值的向量
            for (int i = q.size(); i > 0 ; i--) {   //存储某一层节点值以及下一层的节点
                TreeNode* node = q.front();
                q.pop();
                level.push_back( node->val );
                if ( node->left )
                    q.push( node->left );
                if ( node->right )
                    q.push( node->right );
            }
            res.insert( res.begin(), level );                  //以逆层序存储得到最终结果
        }
        return res;
    }
};

提交后的结果如下：

 

方法二（队列法）

与“https://blog.csdn.net/Vensmallzeng/article/details/88924863”中方法二的思路一样，只是改变了节点值的存储顺序而已。

class Solution{
public:
    vector<vector<int>> levelOrderBottom(TreeNode* root){
        vector<vector<int>> res;
        if ( !root )
            return res;
        queue< TreeNode* > q;
        q.push( root );
        while ( !q.empty() ){
            vector<int> level;                                //建立存放每一层节点值的向量
            for (int i = q.size(); i > 0 ; i--) {             //存储某一层节点值以及下一层的节点
                TreeNode* node = q.front();
                q.pop();
                level.push_back( node->val );
                if ( node->left )
                    q.push( node->left );
                if ( node->right )
                    q.push( node->right );
            }
            res.insert( res.begin(), level );                  //以逆层序存储得到最终结果
        }
        return res;
    }
};

提交后的结果如下：

 

方法三（递归法）

与“https://blog.csdn.net/Vensmallzeng/article/details/88924863”中方法三的思路一样，只是通过反向迭代器改变了res的存储顺序而已。

class Solution {
public:
    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        vector<vector<int>> res;
        levelorder(root, 0, res);   //传入根节点、树的层序、存储结果的向量进行递归调用
        return vector<vector<int>> ( res.rbegin(), res.rend() );   //将原二维向量反向迭代生成新的二维向量
    }

    void levelorder(TreeNode* node, int level, vector<vector<int>>& res) {
        if ( !node ) return;        //如果节点为空则结束本次调用

        if ( res.size() == level ) res.push_back( vector<int>() );    //按不同层分别存储节点值
        res[level].push_back( node->val );

        if ( node->left ) levelorder( node->left, level + 1, res );   //对根节点的左子结点这一串进行深度优先遍历
        if ( node->right ) levelorder( node->right, level + 1, res ); //对根节点的右子结点这一串进行深度优先遍历
    }
};

提交后的结果如下：

 

 

日积月累，与君共进，增增小结，未完待续。