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] ]
思路,采用广度优先搜索的策略,使用队列作为数据结构,当一层节点压入队列后,依次取出将该层节点的下一层节点全部压入队列中,再依次执行操作,层与层之间,使用null节点分割
另外一个问题是,我们处理数据是自顶向下,然而需要的输出结果是自底向上的,因此我定义了另外一个list,将结果list反向倒入目标list中
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
public class Solution {
int count(TreeNode x)
{
if(x==null)
return 0;
else
{
int lc=count(x.left);
int rc=count(x.right);
return lc+rc+1;
}
}
int height(TreeNode x)
{
if(x==null)
return 0;
else
{
int lh=height(x.left);
int rh=height(x.right);
if(lh>rh)
return lh+1;
else
return rh+1;
}
}
TreeNode[] queue;
int start=0;
int end=0;
int size=0;
void enqueue(TreeNode x)
{
queue[start]=x;
//if(isEmpty())
// end=(end+1)%size;
start=(start+1)%size;
}
TreeNode outqueue()
{
//start=(start-1)%size;
end=(end+1)%size;
return queue[(end-1)%size];
}
boolean isEmpty()
{
if(end==start)
return true;
else
return false;
}
public List<List<Integer>> levelOrderBottom(TreeNode root) {
List<List<Integer>> listl=new ArrayList<List<Integer>>();
List<List<Integer>> listend=new ArrayList<List<Integer>>();
size=(count(root)+1)*10;
int H=height(root);
//List<Integer>[] v;
//for(int i=0;i<H;i++)
// v[i]=new ArrayList<Integer>();
queue=new TreeNode[size];
for(int i=0;i<size;i++)
queue[i]=new TreeNode(0);
TreeNode y=null;
enqueue(root);
enqueue(y);
int c=0;
while(!isEmpty())
{
boolean t=false;
List<Integer> l=new ArrayList<Integer>();
TreeNode z=outqueue();
while(z!=null)
{
l.add(z.val);
if(z.left!=null)
{
enqueue(z.left);
t=true;
}
if(z.right!=null)
{
enqueue(z.right);
t=true;
}
z=outqueue();
}
if(!l.isEmpty())
listl.add(l);
if(t)
{
enqueue(y);
c++;
}
}
//以下是反向输出结果,使输出结果从自顶向下转变为自底向上
for(int j=listl.size()-1;j>=0;j--)
listend.add(listl.get(j));
return listend;
}
}