70 二叉树的层次遍历 II

原题网址：http://www.lintcode.com/zh-cn/problem/binary-tree-level-order-traversal-ii/

给出一棵二叉树，返回其节点值从底向上的层次序遍历（按从叶节点所在层到根节点所在的层遍历，然后逐层从左往右遍历）

您在真实的面试中是否遇到过这个题？ 

Yes

样例

给出一棵二叉树 {3,9,20,#,#,15,7},

    3
   / 
  9  20
    /  
   15   7

按照从下往上的层次遍历为：

[
  [15,7],
  [9,20],
  [3]
]

标签 

队列 二叉树 二叉树遍历 宽度优先搜索

 

思路：此前做过二叉树的层次遍历，代码大致相同，只是多设置了一个栈存储每层节点数值的数组，遍历完二叉树后，将栈中数组压入结果数组中就OK了。

 

/**
 * Definition of TreeNode:
 * class TreeNode {
 * public:
 *     int val;
 *     TreeNode *left, *right;
 *     TreeNode(int val) {
 *         this->val = val;
 *         this->left = this->right = NULL;
 *     }
 * }
 */

class Solution {
public:
    /**
     * @param root: A tree
     * @return: buttom-up level order a list of lists of integer
     */
    vector<vector<int>> levelOrderBottom(TreeNode * root) {
        // write your code here
        vector<vector<int>> result;
     if (root==NULL)
     {
         return result;
     }
     stack<vector<int>> s;
     queue<TreeNode *> level;
     level.push(root);
     int len; //计数器，记录每层节点数量;

     while(!level.empty())
     {
         len=level.size();
         vector<int> temp;
         while(len--) //遍历当前层数值，并将当前层节点的左右孩子入队列;
         {
             TreeNode *p=level.front();
             level.pop();
             temp.push_back(p->val);
             if (p->left!=NULL)
             {
                 level.push(p->left);
             }
             if (p->right!=NULL)
             {
                 level.push(p->right);
             }
         }
         s.push(temp);
     }
     while(!s.empty())
     {
         vector<int> t=s.top();
         result.push_back(t);
         s.pop();
     }
     return result;
    }
};

另一种方法： 用两个vector代替queue保存层节点。

注：翻转数组时可使用reverse（）函数。

/**
 * Definition of TreeNode:
 * class TreeNode {
 * public:
 *     int val;
 *     TreeNode *left, *right;
 *     TreeNode(int val) {
 *         this->val = val;
 *         this->left = this->right = NULL;
 *     }
 * }
 */

class Solution {
public:
    /**
     * @param root: A tree
     * @return: buttom-up level order a list of lists of integer
     */
    vector<vector<int>> levelOrderBottom(TreeNode * root) {
        // write your code here
        vector<vector<int>> result;
     if (root==NULL)
     {
         return result;
     }
     vector<vector<TreeNode *>> levelNode; //所有层节点;
     vector<TreeNode *> preLevelNode;
     preLevelNode.push_back(root);
     levelNode.push_back(preLevelNode);

     while(!preLevelNode.empty())
     {
         vector<TreeNode *> curLevelNode;
         for (int i=0;i<(int)preLevelNode.size();i++)
         {
             TreeNode *p=preLevelNode[i];
             if (p->left!=NULL)
             {
                 curLevelNode.push_back(p->left);
             }
             if (p->right!=NULL)
             {
                 curLevelNode.push_back(p->right);
             }
         } 
         levelNode.push_back(curLevelNode);
         preLevelNode.assign(curLevelNode.begin(),curLevelNode.end());
     }
     levelNode.pop_back();//注意最后一次压入的是空数组，所以循环终止，遍历时应剔除尾部的空数组;
     for (int i=levelNode.size()-1;i>=0;i--)
     {
         vector<int> temp;
         for (int j=0;j<(int)levelNode[i].size();j++)
         {
             temp.push_back(levelNode[i][j]->val);
         }
         result.push_back(temp);
     }
     return result;
    }
};