如何按层遍历树 如何按层遍历普通树 注意不是二叉树 是普通树

最近遇到个需求，要求按层遍历普通树 ，这里不是二叉树，二叉树的遍历算法很多，不在此说明，今天用java算法来写写怎么从最下面的层 从左往右  逐个往上遍历一颗普通树

/**
 * @author hdy
 * @version 创建时间：2013-3-8 下午1:53:19
 * 
 */
public abstract class Component {
public abstract Component getParent();
public abstract List<Component> getChildren();
public abstract DirImportDto getNodeData();
public abstract boolean isLeaf() ;
public abstract void setParent(Component parent) ;
public abstract void setChildren(List<Component> children) ;
public abstract void setNodeData(DirImportDto node) ;
public abstract void setLeaf(boolean isLeaf);
public abstract void iteratorTree(Map<String,List<DirImportDto>> depthMap);
public abstract TreeNode addChildNode(Component node);
public abstract int getDepth();
public abstract void setDepth(int depth);
}

/**
 * @author hdy
 * @version 创建时间：2013-3-8 下午1:52:04
 *  存放每个节点数据的地方
 */
public class DirImportDto {
private int key;
private String dir;
public int getKey() {
return key;
}
public String getDir() {
return dir;
}
public void setKey(int key) {
this.key = key;
}
public void setDir(String dir) {
this.dir = dir;
}

}

/**
 * @author hdy
 * @version 创建时间：2013-3-8 下午1:47:15
 * 树节点
 */
public class TreeNode extends Component{
private Component parent;
private List<Component> children =new ArrayList<Component>();//孩子
private DirImportDto nodeData;//节点内容
private boolean isLeaf;//是否是叶子节点
private int depth;//层

public TreeNode(){

}
public TreeNode(String nodeDateDir){
DirImportDto importDto = new DirImportDto();
importDto.setDir(nodeDateDir);
this.setNodeData(importDto);
}
public int getDepth() {
return depth;
}
public void setDepth(int depth) {
this.depth = depth;
}
public Component getParent() {
return parent;
}
public List<Component> getChildren() {
return children;
}
 
public boolean isLeaf() {
if(children!=null && children.size()>0){
isLeaf=false;
}else{
isLeaf=true;
}
return isLeaf;
}
public void setParent(Component parent) {
this.parent = parent;
this.setDepth(parent.getDepth()+1);//深度加1
}
public void setChildren(List<Component> children) {
this.children = children;
}
 
public DirImportDto getNodeData() {
return nodeData;
}
public void setNodeData(DirImportDto nodeData) {
this.nodeData = nodeData;
}
public void setLeaf(boolean isLeaf) {
this.isLeaf = isLeaf;
}

public void iteratorTree(Map<String,List<DirImportDto>> depthMap){
this.dealDepthData(depthMap);
if(!isLeaf()){
System.out.println("深度："+this.getDepth()+"内容："+this.getNodeData().getDir());
for(Component node:this.getChildren()){
node.iteratorTree(depthMap);
}
}else{//遇到叶子打印此节点
System.out.println("深度："+this.getDepth()+"内容："+this.getNodeData().getDir());
}
}
//处理层结构数据：
private void dealDepthData(Map<String,List<DirImportDto>> depthMap){
String key = this.getDepth()+"";
if(depthMap.get(key)!=null){
depthMap.get(key).add(this.getNodeData());
}else{
List<DirImportDto> ls = new ArrayList<DirImportDto>();
ls.add(this.getNodeData());
depthMap.put(key, ls);
}
}
@Override
public TreeNode addChildNode(Component node) {
this.getChildren().add(node);
node.setParent(this);//设置孩子的父节点为自己
return this;
}

}

public class TreeTest {


/**
* @param args
*/
public static void main(String[] args) {
Component root = new TreeNode();
DirImportDto i1 = new DirImportDto();
i1.setKey(1001);
root.setNodeData(i1);
root.setDepth(1);
//---------第一层结束---------
Component node21 = new TreeNode();
DirImportDto i21 = new DirImportDto();
i21.setKey(2001);
node21.setNodeData(i21);

Component node22 = new TreeNode();
DirImportDto i22 = new DirImportDto();
i22.setKey(2002);
node22.setNodeData(i22);

Component node23 = new TreeNode();
DirImportDto i23 = new DirImportDto();
i23.setKey(2003);
node23.setNodeData(i23);

root.addChildNode(node21);
root.addChildNode(node22);
root.addChildNode(node23);
//---------第二层结束--------
Component node31 = new TreeNode();
DirImportDto i31 = new DirImportDto();
i31.setKey(3001);
node31.setNodeData(i31);
Component node32 = new TreeNode();
DirImportDto i32 = new DirImportDto();
i32.setKey(3002);
node32.setNodeData(i32);

node21.addChildNode(node31);
node22.addChildNode(node32);
//-----------第三层结束-------

//普通树的按层遍历算法
Map<String,List<DirImportDto>> depthMap = new HashMap<String,List<DirImportDto>>();
root.iteratorTree(depthMap);
// Set valueSet = depthMap.entrySet();
// Iterator it = valueSet.iterator();
// while(it.hasNext()){
// Object obj = it.next();
// }
Set<String> keySet = depthMap.keySet();
Iterator<String> itKey = keySet.iterator();
while(itKey.hasNext()){
String key = (String)itKey.next();
System.out.println(key);
List<DirImportDto> ls = depthMap.get(key);
for(DirImportDto dto : ls){
System.out.println(">>>"+dto.getKey());
}
}
}


}

输出结果：

3
>>>3001
>>>3002
2
>>>2001
>>>2002
>>>2003
1
>>>1001

说明 这里我主要是利用了hashMap 他的key值存放的就是节点当前所处的层，如果遇到相同层上的节点，就放在value中 ，value是个arrayList 

至于树就是普通的一棵树，

如果大家有更好的方法 欢迎讨论