【LeetCode】BinaryTreeLevelOrderTraversal_ii 二叉树的层次遍历 II

二叉树的层次遍历 II

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

样例
给出一棵二叉树 {3,9,20,#,#,15,7},
3
/ \
9  20
/  \
15   7
按照从下往上的层次遍历为：
[
[15,7],
[9,20],
[3]
]

标签

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

相关题目

中等Search Graph Nodes45 %

（1）Java

import BinaryTree.TreeNode;

import java.util.*;

public class BinaryTreeLevelOrderTraversal_ii {
/*
* @param root: A tree
* @return: buttom-up level order a list of lists of integer
*/
public List<List<Integer>> levelOrderBottom(TreeNode root) {
List<List<Integer>> results = new ArrayList<>();
if(root == null){
return results;
}
Queue<TreeNode> queue = new LinkedList<TreeNode>();
queue.offer(root);

while(!queue.isEmpty()){
List<Integer> buffer = new ArrayList<>();//must be defined in while-loop!!
int size = queue.size();
for(int i = 0; i < size; i++){
TreeNode head = queue.poll();
buffer.add(head.val);
if(head.left != null){
queue.offer(head.left);
}
if(head.right != null){
queue.offer(head.right);
}
}
results.add(buffer);
}

Collections.reverse(results);//
return results;
}
}

（2）C++

#include <stdio.h>
#include <vector>
#include <queue>
#include <algorithm>
using namespace std;

/*--- binary-tree-level-order-traversal(ii) ---*/

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

//Version 1 : 1 Queue【Recommend】
class BinaryTreeLevelOrderTraversal_ii{
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>> results;
if(root == NULL){
return results;
}

queue<TreeNode*> Q;
Q.push(root);
while (!Q.empty()) {
vector<int> buffer;
int size = Q.size();

for(int i = 0; i < size; i++){
TreeNode* root = Q.front(); Q.pop();
buffer.push_back(root->val);
if(root->left != NULL){
Q.push(root->left);
}
if(root->right != NULL){
Q.push(root->right);
}
}
results.push_back(buffer);
}
reverse(results.begin(), results.end());
return results;
}
};
//Version 2 : 1 Queue + Dummy Node
class BinaryTreeLevelOrderTraversal_ii_V2 {
/**
* @param root : The root of binary tree.
* @return : buttom-up level order a list of lists of integer
*/
public:
vector<vector<int>> levelOrderBottom(TreeNode *root) {
// write your code here
vector<vector<int> > ret;
ret.clear();
if(root == NULL)
return ret;
queue<TreeNode*> S;
S.push(root);
S.push(NULL);
vector<int> tmp;
while(!S.empty()){
//travesal current level
TreeNode* p = S.front();
S.pop();
if(p!=NULL)
{
tmp.push_back(p->val);
if(p->left)
S.push(p->left);
if(p->right)
S.push(p->right);
}else{
if(!tmp.empty())
{
S.push(NULL);
ret.push_back(tmp);
tmp.clear();
}
}
}
reverse(ret.begin(),ret.end());
return ret;
}
};