java多叉树的生成和遍历

转载另外一个关于多叉树的实现类：

[java]  view plain  copy

1. /* 
2.  * Copyright Walker Studio 
3.  * All Rights Reserved. 
4.  *  
5.  * 文件名称： TreeNode.java 
6.  * 摘 要： 
7.  * 作 者： Walker 
8.  * 创建时间： 2013-03-19 
9.  */  
10. package com.walker.commons.data.model;  
11.   
12. /** 
13.  * 树节点 
14.  *  
15.  * @author Walker 
16.  * @version 1.0.0.0 
17.  */  
18. public class TreeNode   
19. {  
20.     /** 节点Id*/  
21.     private String nodeId;  
22.     /** 父节点Id*/  
23.     private String parentId;  
24.     /** 文本内容*/  
25.     private String text;  
26.       
27.     /** 
28.      * 构造函数 
29.      *  
30.      * @param nodeId 节点Id 
31.      */  
32.     public TreeNode(String nodeId)  
33.     {  
34.         this.nodeId = nodeId;  
35.     }  
36.       
37.     /** 
38.      * 构造函数 
39.      *  
40.      * @param nodeId 节点Id 
41.      * @param parentId 父节点Id 
42.      */  
43.     public TreeNode(String nodeId, String parentId)  
44.     {  
45.         this.nodeId = nodeId;  
46.         this.parentId = parentId;  
47.     }  
48.   
49.     public String getNodeId() {  
50.         return nodeId;  
51.     }  
52.   
53.     public void setNodeId(String nodeId) {  
54.         this.nodeId = nodeId;  
55.     }  
56.   
57.     public String getParentId() {  
58.         return parentId;  
59.     }  
60.   
61.     public void setParentId(String parentId) {  
62.         this.parentId = parentId;  
63.     }  
64.   
65.     public String getText() {  
66.         return text;  
67.     }  
68.   
69.     public void setText(String text) {  
70.         this.text = text;  
71.     }  
72.       
73. }  

ManyTreeNode.java

[java]  view plain  copy

1. /* 
2.  * Copyright Walker Studio 
3.  * All Rights Reserved. 
4.  *  
5.  * 文件名称： ManyTreeNode.java 
6.  * 摘 要： 
7.  * 作 者： Walker 
8.  * 创建时间： 2013-03-19 
9.  */  
10. package com.walker.commons.data.model;  
11.   
12. import java.util.ArrayList;  
13. import java.util.List;  
14.   
15. /** 
16.  * 多叉树节点 
17.  * 
18.  * @author Walker 
19.  * @verion 1.0.0.0 
20.  */  
21. public class ManyTreeNode   
22. {  
23.     /** 树节点*/  
24.     private TreeNode data;  
25.     /** 子树集合*/  
26.     private List<ManyTreeNode> childList;  
27.       
28.     /** 
29.      * 构造函数 
30.      *  
31.      * @param data 树节点 
32.      */  
33.     public ManyTreeNode(TreeNode data)  
34.     {  
35.         this.data = data;  
36.         this.childList = new ArrayList<ManyTreeNode>();  
37.     }  
38.       
39.     /** 
40.      * 构造函数 
41.      *  
42.      * @param data 树节点 
43.      * @param childList 子树集合 
44.      */  
45.     public ManyTreeNode(TreeNode data, List<ManyTreeNode> childList)  
46.     {  
47.         this.data = data;  
48.         this.childList = childList;  
49.     }  
50.   
51.     public TreeNode getData() {  
52.         return data;  
53.     }  
54.   
55.     public void setData(TreeNode data) {  
56.         this.data = data;  
57.     }  
58.   
59.     public List<ManyTreeNode> getChildList() {  
60.         return childList;  
61.     }  
62.   
63.     public void setChildList(List<ManyTreeNode> childList) {  
64.         this.childList = childList;  
65.     }  
66.   
67. }  

ManyNodeTree.java

[java]  view plain  copy

1. /* 
2.  * Copyright Walker Studio 
3.  * All Rights Reserved. 
4.  *  
5.  * 文件名称： ManyNodeTree.java 
6.  * 摘 要： 
7.  * 作 者： Walker 
8.  * 创建时间： 2013-03-19 
9.  */  
10. package com.walker.commons.data.model;  
11.   
12. import java.util.ArrayList;  
13. import java.util.List;  
14.   
15. /** 
16.  * 多叉树生成、遍历工具 
17.  *  
18.  * @author Walker 
19.  * @version 1.0.0.0 
20.  */  
21. public class ManyNodeTree   
22. {  
23.     /** 树根*/  
24.     private ManyTreeNode root;  
25.       
26.     /** 
27.      * 构造函数 
28.      */  
29.     public ManyNodeTree()  
30.     {  
31.         root = new ManyTreeNode(new TreeNode("root"));  
32.     }  
33.       
34.     /** 
35.      * 生成一颗多叉树，根节点为root 
36.      *  
37.      * @param treeNodes 生成多叉树的节点集合 
38.      * @return ManyNodeTree 
39.      */  
40.     public ManyNodeTree createTree(List<TreeNode> treeNodes)  
41.     {  
42.         if(treeNodes == null || treeNodes.size() < 0)  
43.             return null;  
44.           
45.         ManyNodeTree manyNodeTree =  new ManyNodeTree();  
46.           
47.         //将所有节点添加到多叉树中  
48.         for(TreeNode treeNode : treeNodes)  
49.         {  
50.             if(treeNode.getParentId().equals("root"))  
51.             {  
52.                 //向根添加一个节点  
53.                 manyNodeTree.getRoot().getChildList().add(new ManyTreeNode(treeNode));  
54.             }  
55.             else  
56.             {  
57.                 addChild(manyNodeTree.getRoot(), treeNode);  
58.             }  
59.         }  
60.           
61.         return manyNodeTree;  
62.     }  
63.       
64.     /** 
65.      * 向指定多叉树节点添加子节点 
66.      *  
67.      * @param manyTreeNode 多叉树节点 
68.      * @param child 节点 
69.      */  
70.     public void addChild(ManyTreeNode manyTreeNode, TreeNode child)  
71.     {  
72.         for(ManyTreeNode item : manyTreeNode.getChildList())  
73.         {  
74.             if(item.getData().getNodeId().equals(child.getParentId()))  
75.             {  
76.                 //找到对应的父亲  
77.                 item.getChildList().add(new ManyTreeNode(child));  
78.                 break;  
79.             }  
80.             else  
81.             {  
82.                 if(item.getChildList() != null && item.getChildList().size() > 0)  
83.                 {  
84.                     addChild(item, child);  
85.                 }                 
86.             }  
87.         }  
88.     }  
89.       
90.     /** 
91.      * 遍历多叉树  
92.      *  
93.      * @param manyTreeNode 多叉树节点 
94.      * @return  
95.      */  
96.     public String iteratorTree(ManyTreeNode manyTreeNode)  
97.     {  
98.         StringBuilder buffer = new StringBuilder();  
99.         buffer.append("\n");  
100.           
101.         if(manyTreeNode != null)   
102.         {     
103.             for (ManyTreeNode index : manyTreeNode.getChildList())   
104.             {  
105.                 buffer.append(index.getData().getNodeId()+ ",");  
106.                   
107.                 if (index.getChildList() != null && index.getChildList().size() > 0 )   
108.                 {     
109.                     buffer.append(iteratorTree(index));  
110.                 }  
111.             }  
112.         }  
113.           
114.         buffer.append("\n");  
115.           
116.         return buffer.toString();  
117.     }  
118.       
119.     public ManyTreeNode getRoot() {  
120.         return root;  
121.     }  
122.   
123.     public void setRoot(ManyTreeNode root) {  
124.         this.root = root;  
125.     }  
126.       
127.     public static void main(String[] args)  
128.     {  
129.         List<TreeNode> treeNodes = new ArrayList<TreeNode>();  
130.             treeNodes.add(new TreeNode("系统权限管理", "root"));  
131.             treeNodes.add(new TreeNode("用户管理", "系统权限管理"));  
132.             treeNodes.add(new TreeNode("角色管理", "系统权限管理"));  
133.             treeNodes.add(new TreeNode("组管理", "系统权限管理"));  
134.             treeNodes.add(new TreeNode("用户菜单管理", "系统权限管理"));  
135.             treeNodes.add(new TreeNode("角色菜单管理", "系统权限管理"));  
136.             treeNodes.add(new TreeNode("用户权限管理", "系统权限管理"));  
137.             treeNodes.add(new TreeNode("站内信", "root"));  
138.             treeNodes.add(new TreeNode("写信", "站内信"));  
139.             treeNodes.add(new TreeNode("收信", "站内信"));  
140.             treeNodes.add(new TreeNode("草稿", "站内信"));  
141.               
142.             ManyNodeTree tree = new ManyNodeTree();  
143.               
144.             System.out.println(tree.iteratorTree(tree.createTree(treeNodes).getRoot()));  
145.     }  
146.       
147. }