Java中的数据结构（3）----强大的二叉树

简单的排序二叉树

Java代码  

1. package com.wz.util.tree;  
2.   
3. import java.util.ArrayList;  
4. import java.util.Iterator;  
5.   
6. /** 
7.  * 排序二叉树 
8.  *  
9.  * @author NumbCoder 
10.  *  
11.  */  
12. // 节点  
13. class BinaryNode {  
14.     private int data;  
15.     BinaryNode lChild;  
16.     BinaryNode rChild;  
17.   
18.     BinaryNode(int t) {  
19.         setData(t);  
20.         lChild = null;  
21.         rChild = null;  
22.     }  
23.   
24.     // 是否为叶子节点  
25.     public boolean isLeaf() {  
26.         if (lChild == null && rChild == null)  
27.             return true;  
28.         else  
29.             return false;  
30.     }  
31.   
32.     public void setData(int data) {  
33.         this.data = data;  
34.     }  
35.   
36.     public int getData() {  
37.         return data;  
38.     }  
39. }  
40.   
41. // 树  
42. public class BinaryTree {  
43.     private BinaryNode root;  
44.   
45.     BinaryTree(BinaryNode root) {  
46.         this.root = root;  
47.         root.lChild = null;  
48.         root.rChild = null;  
49.     }  
50.   
51.     // 向二叉树中插入一个节点  
52.     public void insert(BinaryNode n) {  
53.         // 树是空的  
54.         if (root == null)  
55.             root = n;  
56.         else {  
57.             BinaryNode current = root;  
58.             BinaryNode parentNode;  
59.             boolean flag = true;  
60.             while (flag) {  
61.                 parentNode = current;  
62.                 if (n.getData() > current.getData()) {  
63.                     // 要插入的节点为右孩子节点  
64.                     current = current.rChild;  
65.                     if (current == null) {  
66.                         parentNode.rChild = n;  
67.                         flag = false;  
68.                     }  
69.                 } else if (n.getData() < current.getData()) {  
70.                     current = current.lChild;  
71.                     // 要插入的节点为左孩子节点  
72.                     if (current == null) {  
73.                         parentNode.lChild = n;  
74.                         flag = false;  
75.                     }  
76.                 }  
77.             }  
78.         }  
79.     }  
80.   
81.     // 传入一个裝有节点的ArrayList便可自动生成一棵排序二叉树  
82.     public void creatBinaryTree(BinaryNode root, ArrayList<BinaryNode> aList) {  
83.         Iterator<BinaryNode> it = aList.iterator();  
84.         while (it.hasNext()) {  
85.             insert(it.next());  
86.         }  
87.     }  
88.   
89.     // 先序遍历  
90.     public void preOrder(BinaryNode t) {  
91.         if (t != null) {  
92.             System.out.println(t.getData());  
93.             preOrder(t.lChild);  
94.             preOrder(t.rChild);  
95.         }  
96.     }  
97.   
98.     // 中序遍历  
99.     public void inOrder(BinaryNode t) {  
100.         if (t != null) {  
101.             inOrder(t.lChild);  
102.             System.out.println(t.getData());  
103.             inOrder(t.rChild);  
104.         }  
105.     }  
106.   
107.     // 后序遍历  
108.     public void postOrder(BinaryNode t) {  
109.         if (t != null) {  
110.             postOrder(t.lChild);  
111.             postOrder(t.rChild);  
112.             System.out.println(t.getData());  
113.         }  
114.     }  
115.   
116. }  

 泛型的排序二叉树（因为是排序的，所以节点必须具有可比性，但具体的比较规则自己定）

Java代码  

1. package com.wz.util;  
2.   
3. import java.util.ArrayList;  
4. import java.util.Iterator;  
5.   
6. /** 
7.  * 带泛型的排序二叉树 
8.  *  
9.  * @author NumbCoder 
10.  *  
11.  */  
12.   
13.    
14.   class BinaryNode<T> implements Comparable<T>  {  
15.     private T data;  
16.     BinaryNode<T> lChild;  
17.     BinaryNode<T> rChild;  
18.   
19.     BinaryNode(T t) {  
20.         setData(t);  
21.         lChild = null;  
22.         rChild = null;  
23.     }  
24.   
25.     /** 
26.      * 根据T的类型自定义比较方法小于、等于或大于n分别返回负-1、0或1  
27.      * 必须实现具体compareTo方法 
28.      */  
29.     @Override  
30.     public int compareTo(T t) {  
31.           
32.             return 0;  
33.     }  
34.     public void setData(T data) {  
35.         this.data = data;  
36.     }  
37.   
38.     public T getData() {  
39.         return data;  
40.     }  
41. //是否为叶子节点  
42.     public boolean isLeaf() {  
43.         if (lChild == null && rChild == null)  
44.             return true;  
45.         else  
46.             return false;  
47.     }  
48.   
49.       
50.   
51.       
52. }  
53. //树  
54. public class BinaryTree<T> {  
55.     private BinaryNode<T> root;  
56.   
57.     BinaryTree(BinaryNode<T> root) {  
58.         this.root = root;  
59.         root.lChild = null;  
60.         root.rChild = null;  
61.     }  
62.   
63.     // 向二叉树中插入一个节点  
64.     public void insert(BinaryNode<T> n) {  
65.         // 树是空的  
66.         if (root == null)  
67.             root = n;  
68.         else {  
69.             BinaryNode<T> current = root;  
70.             BinaryNode<T> parentNode;  
71.             boolean flag = true;  
72.             while (flag) {  
73.                 parentNode = current;  
74.                 if (n.compareTo(current.getData()) == 1) {  
75.                     // 要插入的节点为右孩子节点  
76.                     current = current.rChild;  
77.                     if (current == null) {  
78.                         parentNode.rChild = n;  
79.                         flag = false;  
80.                     }  
81.                 } else if( n.compareTo(current.getData()) == -1){  
82.                     current = current.lChild;  
83.                     // 要插入的节点为左孩子节点  
84.                     if (current == null) {  
85.                         parentNode.lChild = n;  
86.                         flag = false;  
87.                     }  
88.                 }  
89.             }  
90.         }  
91.     }  
92.   
93.     // 生成一棵排序二叉树  
94.     public void creatBinaryTree(BinaryNode<T> root,  
95.             ArrayList<BinaryNode<T>> aList) {  
96.         Iterator<BinaryNode<T>> it = aList.iterator();  
97.         while (it.hasNext()) {  
98.             insert(it.next());  
99.         }  
100.     }  
101.   
102.     // 先序遍历  
103.     private void preOrder(BinaryNode<T> t, ArrayList<T> list) {  
104.         if (t != null) {  
105.             list.add(t.getData());  
106.             preOrder(t.lChild, list);  
107.             preOrder(t.rChild, list);  
108.         }  
109.     }  
110.   
111.     public Iterator<T> itPreOrder() {  
112.         ArrayList<T> list = new ArrayList<T>();  
113.         preOrder(root, list);  
114.         return list.iterator();  
115.     }  
116.   
117.     // 中序遍历  
118.     private void inOrder(BinaryNode<T> t, ArrayList<T> list) {  
119.         if (t != null) {  
120.             inOrder(t.lChild, list);  
121.             list.add(t.getData());  
122.             inOrder(t.rChild, list);  
123.         }  
124.     }  
125.   
126.     public Iterator<T> itInOrder() {  
127.         ArrayList<T> list = new ArrayList<T>();  
128.         inOrder(root, list);  
129.         return list.iterator();  
130.     }  
131.   
132.     // 后序遍历  
133.     private void postOrder(BinaryNode<T> t, ArrayList<T> list) {  
134.         if (t != null) {  
135.             postOrder(t.lChild, list);  
136.             postOrder(t.rChild, list);  
137.             list.add(t.getData());  
138.         }  
139.     }  
140.   
141.     public Iterator<T> itPostOrder() {  
142.         ArrayList<T> list = new ArrayList<T>();  
143.         postOrder(root, list);  
144.         return list.iterator();  
145.     }  
146. }