java实现二叉树的常见操作

 

       树型结构是最常见的非线性结构，其中二叉树最为常见。今天我主要就是用java来实现一下树的一些常见操作。

       首先需要一个用来存储树节点值的javabean：

[java] view plaincopyprint?

1. public class TreeBean {  
2.       
3.     private int nodeValue;  
4.       
5.     public int getNodeValue() {  
6.         return nodeValue;  
7.     }  
8.   
9.     public void setNodeValue(int nodeValue) {  
10.         this.nodeValue = nodeValue;  
11.     }  
12. }  

public class TreeBean {private int nodeValue;public int getNodeValue() {return nodeValue;}public void setNodeValue(int nodeValue) {this.nodeValue = nodeValue;}}

       然后是树的节点bean：

[java] view plaincopyprint?

1. public class TreeNode{  
2.   
3.     private TreeBean data;  
4.     private TreeNode leftNode;  
5.     private TreeNode rightNode;  
6.       
7.     //构造函数     
8.     public TreeNode(){    
9.         data = new TreeBean();    
10.     }  
11.       
12.     public TreeBean getData() {  
13.         return data;  
14.     }  
15.   
16.     public void setData(TreeBean data) {  
17.         this.data = data;  
18.     }  
19.   
20.     public TreeNode getLeftNode() {  
21.         return leftNode;  
22.     }  
23.     public void setLeftNode(TreeNode leftNode) {  
24.         this.leftNode = leftNode;  
25.     }  
26.     public TreeNode getRightNode() {  
27.         return rightNode;  
28.     }  
29.     public void setRightNode(TreeNode rightNode) {  
30.         this.rightNode = rightNode;  
31.     }  
32.   
33. }  

public class TreeNode{private TreeBean data;private TreeNode leftNode;private TreeNode rightNode;//构造函数      public TreeNode(){          data = new TreeBean();      }public TreeBean getData() {return data;}public void setData(TreeBean data) {this.data = data;}public TreeNode getLeftNode() {return leftNode;}public void setLeftNode(TreeNode leftNode) {this.leftNode = leftNode;}public TreeNode getRightNode() {return rightNode;}public void setRightNode(TreeNode rightNode) {this.rightNode = rightNode;}}

       最后是Tree的主体：

[java] view plaincopyprint?

1. public class Tree {  
2.     //树的根节点   
3.     private TreeNode root;  
4.     public TreeNode getRoot() {  
5.         return root;  
6.     }  
7.     public void setRoot(TreeNode root) {  
8.         this.root = root;  
9.     }  
10.       
11.     //无参构造函数   
12.     Tree(){}  
13.       
14.     Tree(int nodeValue){  
15.         root = new TreeNode();  
16.         TreeBean nodeBean = new TreeBean();    
17.         nodeBean.setNodeValue(nodeValue);  
18.         root.setData(nodeBean);  
19.     }  
20.     /** 
21.      * 销毁树，将树置空。 
22.      * @author letthinking 
23.      * @param tree 
24.      * @return 
25.      */  
26.     public static Tree destroy(Tree tree){  
27.         return null;  
28.     }  
29.     /** 
30.      * 给树插入数据 
31.      * @author letthinking 
32.      * @param root 
33.      * @param node 
34.      */  
35.     public void insert(TreeNode root,TreeNode node){  
36.         //如果根节点为空，则赋值给根节点   
37.         if(root == null){  
38.             root = node;  
39.         }else{  
40.             //该节点与它的双亲节点比较，如果小于双亲节点，就将它作为左孩子，否则为右孩子。  
41.             if(node.getData().getNodeValue() < root.getData().getNodeValue()){  
42.                 //判断该节点是否为空，如果不为空就继续递归。   
43.                 if(root.getLeftNode() == null){  
44.                     root.setLeftNode(node);  
45.                 }else{  
46.                     insert(root.getLeftNode(),node);  
47.                 }  
48.             }else{  
49.                 if(root.getRightNode() == null){  
50.                     root.setRightNode(node);  
51.                 }else{  
52.                     insert(root.getRightNode(),node);  
53.                 }  
54.             }  
55.         }  
56.     }  
57.       
58.     /** 
59.      * 将树的所有节点清空 
60.      * @author letthinking 
61.      * @param root 树的根节点 
62.      */  
63.     public void clearTree(TreeNode root){  
64.           
65.         if(root.getData() == null){  
66.             if(root.getLeftNode() != null){  
67.                 clearTree(root.getLeftNode());  
68.             }  
69.             if(root.getRightNode() != null){  
70.                 clearTree(root.getRightNode());  
71.             }         
72.         }else{  
73.             root.setData(null);  
74.             if(root.getLeftNode() != null){  
75.                 clearTree(root.getLeftNode());  
76.             }  
77.             if(root.getRightNode() != null){  
78.                 clearTree(root.getRightNode());  
79.             }     
80.         }  
81.     }  
82.       
83.     /** 
84.      * 前序遍历二叉树   
85.      * @author letthinking 
86.      * @param root 
87.      * @return 
88.      */  
89.     public String middleIterator(TreeNode root){  
90.         StringBuilder str = new StringBuilder();  
91.         //判断节点是否为空   
92.         if(root == null){  
93.             return str.toString();  
94.         }else{  
95.             //输出节点的值   
96.             if(root.getData() != null){  
97.                 str.append(root.getData().getNodeValue()+",");  
98.             }else{  
99.                 str.append("null,");  
100.             }  
101.             //递归输出左孩子的值   
102.             str.append(middleIterator(root.getLeftNode()));  
103.             //递归输出右孩子的值   
104.             str.append(middleIterator(root.getRightNode()));  
105.         }  
106.         return str.toString();  
107.     }  
108.       
109.     /** 
110.      * 后序遍历二叉树   
111.      * @author letthinking 
112.      * @param root 
113.      * @return 
114.      */  
115.     public String afterIterator(TreeNode root){  
116.         StringBuilder str = new StringBuilder();  
117.         //判断节点是否为空   
118.         if(root == null){  
119.             return str.toString();  
120.         }else{  
121.             //递归输出左孩子的值   
122.             str.append(afterIterator(root.getLeftNode()));  
123.             //递归输出右孩子的值   
124.             str.append(afterIterator(root.getRightNode()));  
125.             //输出节点的值   
126.             if(root.getData() != null){  
127.                 str.append(root.getData().getNodeValue()+",");  
128.             }else{  
129.                 str.append("null,");  
130.             }  
131.         }  
132.         return str.toString();  
133.     }  
134.       
135.     /** 
136.      * 求树的深度 
137.      * @author letthinking 
138.      * @param node 
139.      * @return 
140.      */  
141.     public int treeDepth(TreeNode node){  
142.         //定义两个变量用来存储左深度和右深度   
143.         int leftDepth = 0;  
144.         int rightDepth = 0;  
145.         if(node == null){  
146.             return 0;  
147.         }else{  
148.             leftDepth = treeDepth(node.getLeftNode())+1;  
149.             rightDepth = treeDepth(node.getRightNode())+1;  
150.         }  
151.         //返回值最大的深度   
152.         return leftDepth>=rightDepth?leftDepth:rightDepth;  
153.     }  
154.       
155.     public static void main(String [] args){  
156.           
157.         //构造一个只有根节点的空树   
158.         Tree tree = new Tree(35);  
159.         //创建5个节点   
160.         TreeNode treeNode = new TreeNode();  
161.         treeNode.getData().setNodeValue(23);  
162.         TreeNode treeNode1 = new TreeNode();  
163.         treeNode1.getData().setNodeValue(56);  
164.         TreeNode treeNode2 = new TreeNode();  
165.         treeNode2.getData().setNodeValue(45);  
166.         TreeNode treeNode3 = new TreeNode();  
167.         treeNode3.getData().setNodeValue(12);  
168.         TreeNode treeNode4 = new TreeNode();  
169.         treeNode4.getData().setNodeValue(37);  
170.         TreeNode treeNode5 = new TreeNode();  
171.         treeNode5.getData().setNodeValue(19);  
172.         //插入树中   
173.         tree.insert(tree.root, treeNode);  
174.         tree.insert(tree.root, treeNode1);  
175.         tree.insert(tree.root, treeNode2);  
176.         tree.insert(tree.root, treeNode3);  
177.         tree.insert(tree.root, treeNode4);  
178.         tree.insert(tree.root, treeNode5);  
179.         //前序变量   
180.         String result = tree.middleIterator(tree.getRoot());  
181.         System.out.println(result);  
182.         //后序序变量   
183.         result = tree.afterIterator(tree.getRoot());  
184.         System.out.println(result);  
185.         //清空数所有节点的值   
186.         tree.clearTree(tree.getRoot());  
187.         result = tree.middleIterator(tree.getRoot());  
188.         System.out.println(result);  
189.         //得到树的深度   
190.         System.out.println(tree.treeDepth(tree.getRoot()));   
191.     }  
192. }  

public class Tree {//树的根节点private TreeNode root;public TreeNode getRoot() {return root;}public void setRoot(TreeNode root) {this.root = root;}//无参构造函数Tree(){}Tree(int nodeValue){root = new TreeNode();TreeBean nodeBean = new TreeBean();          nodeBean.setNodeValue(nodeValue);        root.setData(nodeBean);}/** * 销毁树，将树置空。 * @author letthinking * @param tree * @return */public static Tree destroy(Tree tree){return null;}/** * 给树插入数据 * @author letthinking * @param root * @param node */public void insert(TreeNode root,TreeNode node){//如果根节点为空，则赋值给根节点if(root == null){root = node;}else{//该节点与它的双亲节点比较，如果小于双亲节点，就将它作为左孩子，否则为右孩子。if(node.getData().getNodeValue() < root.getData().getNodeValue()){//判断该节点是否为空，如果不为空就继续递归。if(root.getLeftNode() == null){root.setLeftNode(node);}else{insert(root.getLeftNode(),node);}}else{if(root.getRightNode() == null){root.setRightNode(node);}else{insert(root.getRightNode(),node);}}}}/** * 将树的所有节点清空 * @author letthinking * @param root 树的根节点 */public void clearTree(TreeNode root){if(root.getData() == null){if(root.getLeftNode() != null){clearTree(root.getLeftNode());}if(root.getRightNode() != null){clearTree(root.getRightNode());}}else{root.setData(null);if(root.getLeftNode() != null){clearTree(root.getLeftNode());}if(root.getRightNode() != null){clearTree(root.getRightNode());}}}/** * 前序遍历二叉树   * @author letthinking * @param root * @return */public String middleIterator(TreeNode root){StringBuilder str = new StringBuilder();//判断节点是否为空if(root == null){return str.toString();}else{//输出节点的值if(root.getData() != null){str.append(root.getData().getNodeValue()+",");}else{str.append("null,");}//递归输出左孩子的值str.append(middleIterator(root.getLeftNode()));//递归输出右孩子的值str.append(middleIterator(root.getRightNode()));}return str.toString();}/** * 后序遍历二叉树   * @author letthinking * @param root * @return */public String afterIterator(TreeNode root){StringBuilder str = new StringBuilder();//判断节点是否为空if(root == null){return str.toString();}else{//递归输出左孩子的值str.append(afterIterator(root.getLeftNode()));//递归输出右孩子的值str.append(afterIterator(root.getRightNode()));//输出节点的值if(root.getData() != null){str.append(root.getData().getNodeValue()+",");}else{str.append("null,");}}return str.toString();}/** * 求树的深度 * @author letthinking * @param node * @return */public int treeDepth(TreeNode node){//定义两个变量用来存储左深度和右深度int leftDepth = 0;int rightDepth = 0;if(node == null){return 0;}else{leftDepth = treeDepth(node.getLeftNode())+1;rightDepth = treeDepth(node.getRightNode())+1;}//返回值最大的深度return leftDepth>=rightDepth?leftDepth:rightDepth;}public static void main(String [] args){//构造一个只有根节点的空树Tree tree = new Tree(35);//创建5个节点TreeNode treeNode = new TreeNode();treeNode.getData().setNodeValue(23);TreeNode treeNode1 = new TreeNode();treeNode1.getData().setNodeValue(56);TreeNode treeNode2 = new TreeNode();treeNode2.getData().setNodeValue(45);TreeNode treeNode3 = new TreeNode();treeNode3.getData().setNodeValue(12);TreeNode treeNode4 = new TreeNode();treeNode4.getData().setNodeValue(37);TreeNode treeNode5 = new TreeNode();treeNode5.getData().setNodeValue(19);//插入树中tree.insert(tree.root, treeNode);tree.insert(tree.root, treeNode1);tree.insert(tree.root, treeNode2);tree.insert(tree.root, treeNode3);tree.insert(tree.root, treeNode4);tree.insert(tree.root, treeNode5);//前序变量String result = tree.middleIterator(tree.getRoot());System.out.println(result);//后序序变量result = tree.afterIterator(tree.getRoot());System.out.println(result);//清空数所有节点的值tree.clearTree(tree.getRoot());result = tree.middleIterator(tree.getRoot());System.out.println(result);//得到树的深度System.out.println(tree.treeDepth(tree.getRoot())); }}

       可能会有地方写的不对，希望大家给指出。