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=;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()-;i>=;i--)
      {
          vector<int> temp;
          for (int j=;j<(int)levelNode[i].size();j++)
          {
              temp.push_back(levelNode[i][j]->val);
          }
          result.push_back(temp);
      }
      return result;
     }
 };