树结构(一) - 二叉树查找树的原理与实现

原文：http://blog.csdn.net/leicool_518/article/details/42491273

一、二叉树查找树的原理

二叉查找树(Binary Search Tree)，它是特殊的二叉树：对于二叉树，假设x为二叉树中的任意一个结点，x节点包含关键字key，节点x的key值记为key[x]。如果y是x的左子树中的一个结点，则key[y] <= key[x]；如果y是x的右子树的一个结点，则key[y] >= key[x]。那么，这棵树就是二叉查找树。如下图所示：

在二叉查找树中：

1、若任意节点的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
2、 任意节点的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
3、 任意节点的左、右子树也分别为二叉查找树。
4、 没有键值相等的节点（no duplicate nodes）。

二、二叉查找树的实现

1. 二叉查找树节点的定义

[html] view plain copy

1. public class BSTree<T extends Comparable<T>> {  
2.   
3.     private BSTNode<T> mRoot;    // 根结点  
4.   
5.     public class BSTNode<T extends Comparable<T>> {  
6.         T key;                // 关键字(键值)  
7.         BSTNode<T> left;      // 左孩子  
8.         BSTNode<T> right;     // 右孩子  
9.         BSTNode<T> parent;    // 父结点  
10.   
11.         public BSTNode(T key, BSTNode<T> parent, BSTNode<T> left, BSTNode<T> right) {  
12.             this.key = key;  
13.             this.parent = parent;  
14.             this.left = left;  
15.             this.right = right;  
16.         }  
17.     }  
18.   
19.         ......  
20. }  

BSTree是二叉树，它保护了二叉树的根节点mRoot；mRoot是BSTNode类型，而BSTNode是二叉查找树的节点，它是BSTree的内部类。BSTNode包含二叉查找树的几个基本信息：
(1) key -- 它是关键字，是用来对二叉查找树的节点进行排序的。
(2) left -- 它指向当前节点的左孩子。
(3) right -- 它指向当前节点的右孩子。
(4) parent -- 它指向当前节点的父结点。

2. 遍历

这里讲解前序遍历、中序遍历、后序遍历3种方式。

2.1 前序遍历

若二叉树非空，则执行以下操作：
(1) 访问根结点；
(2) 先序遍历左子树；
(3) 先序遍历右子树。

[html] view plain copy

1. private void preOrder(BSTNode<T> tree) {  
2.     if(tree != null) {  
3.         System.out.print(tree.key+" ");  
4.         preOrder(tree.left);  
5.         preOrder(tree.right);  
6.     }  
7. }  
8.   
9. public void preOrder() {  
10.     preOrder(mRoot);  
11. }  

2.2 中序遍历

若二叉树非空，则执行以下操作：
(1) 中序遍历左子树；
(2) 访问根结点；
(3) 中序遍历右子树。

[html] view plain copy

1. private void inOrder(BSTNode<T> tree) {  
2.     if(tree != null) {  
3.         inOrder(tree.left);  
4.         System.out.print(tree.key+" ");  
5.         inOrder(tree.right);  
6.     }  
7. }  
8.   
9. public void inOrder() {  
10.     inOrder(mRoot);  
11. }  

2.3 后序遍历

若二叉树非空，则执行以下操作：
(1) 后序遍历左子树；
(2) 后序遍历右子树；
(3) 访问根结点。

[html] view plain copy

1. private void postOrder(BSTNode<T> tree) {  
2.     if(tree != null)  
3.     {  
4.         postOrder(tree.left);  
5.         postOrder(tree.right);  
6.         System.out.print(tree.key+" ");  
7.     }  
8. }  
9.   
10. public void postOrder() {  
11.     postOrder(mRoot);  
12. }  

看看下面这颗树的各种遍历方式：

对于上面的二叉树而言，
(1) 前序遍历结果： 3 1 2 5 4 6
(2) 中序遍历结果： 1 2 3 4 5 6
(3) 后序遍历结果： 2 1 4 6 5 3

3. 查找

递归的代码

[html] view plain copy

1. /*  
2.  * (递归实现)查找"二叉树x"中键值为key的节点  
3.  */  
4. private BSTNode<T> search(BSTNode<T> x, T key) {  
5.     if (x==null)  
6.         return x;  
7.   
8.     int cmp = key.compareTo(x.key);  
9.     if (cmp < 0)  
10.         return search(x.left, key);  
11.     else if (cmp > 0)  
12.         return search(x.right, key);  
13.     else  
14.         return x;  
15. }  
16.   
17. public BSTNode<T> search(T key) {  
18.     return search(mRoot, key);  
19. }  

非递归的代码

[html] view plain copy

1. /*  
2.  * (非递归实现)查找"二叉树x"中键值为key的节点  
3.  */  
4. private BSTNode<T> iterativeSearch(BSTNode<T> x, T key) {  
5.     while (x!=null) {  
6.         int cmp = key.compareTo(x.key);  
7.   
8.         if (cmp < 0)   
9.             x = x.left;  
10.         else if (cmp > 0)   
11.             x = x.right;  
12.         else  
13.             return x;  
14.     }  
15.   
16.     return x;  
17. }  
18.   
19. public BSTNode<T> iterativeSearch(T key) {  
20.     return iterativeSearch(mRoot, key);  
21. }  

4. 最大值和最小值

查找最大值的代码

[html] view plain copy

1. /*   
2.  * 查找最大结点：返回tree为根结点的二叉树的最大结点。  
3.  */  
4. private BSTNode<T> maximum(BSTNode<T> tree) {  
5.     if (tree == null)  
6.         return null;  
7.   
8.     while(tree.right != null)  
9.         tree = tree.right;  
10.     return tree;  
11. }  
12.   
13. public T maximum() {  
14.     BSTNode<T> p = maximum(mRoot);  
15.     if (p != null)  
16.         return p.key;  
17.   
18.     return null;  
19. }  

查找最小值代码

[html] view plain copy

1. /*   
2.  * 查找最小结点：返回tree为根结点的二叉树的最小结点。  
3.  */  
4. private BSTNode<T> minimum(BSTNode<T> tree) {  
5.     if (tree == null)  
6.         return null;  
7.   
8.     while(tree.left != null)  
9.         tree = tree.left;  
10.     return tree;  
11. }  
12.   
13. public T minimum() {  
14.     BSTNode<T> p = minimum(mRoot);  
15.     if (p != null)  
16.         return p.key;  
17.   
18.     return null;  
19. }  

5. 前驱和后继

节点的前驱：是该节点的左子树中的最大节点。
节点的后继：是该节点的右子树中的最小节点。

查找前驱节点的代码

[html] view plain copy

1. /*   
2.  * 找结点(x)的前驱结点。即，查找"二叉树中数据值小于该结点"的"最大结点"。  
3.  */  
4. public BSTNode<T> predecessor(BSTNode<T> x) {  
5.     // 如果x存在左孩子，则"x的前驱结点"为 "以其左孩子为根的子树的最大结点"。  
6.     if (x.left != null)  
7.         return maximum(x.left);  
8.   
9.     // 如果x没有左孩子。则x有以下两种可能：  
10.     // (01) x是"一个右孩子"，则"x的前驱结点"为 "它的父结点"。  
11.     // (01) x是"一个左孩子"，则查找"x的最低的父结点，并且该父结点要具有右孩子"，找到的这个"最低的父结点"就是"x的前驱结点"。  
12.     BSTNode<T> y = x.parent;  
13.     while ((y!=null) && (x==y.left)) {  
14.         x = y;  
15.         y = y.parent;  
16.     }  
17.   
18.     return y;  
19. }  

查找后继节点的代码

[html] view plain copy

1. /*   
2.  * 找结点(x)的后继结点。即，查找"二叉树中数据值大于该结点"的"最小结点"。  
3.  */  
4. public BSTNode<T> successor(BSTNode<T> x) {  
5.     // 如果x存在右孩子，则"x的后继结点"为 "以其右孩子为根的子树的最小结点"。  
6.     if (x.right != null)  
7.         return minimum(x.right);  
8.   
9.     // 如果x没有右孩子。则x有以下两种可能：  
10.     // (01) x是"一个左孩子"，则"x的后继结点"为 "它的父结点"。  
11.     // (02) x是"一个右孩子"，则查找"x的最低的父结点，并且该父结点要具有左孩子"，找到的这个"最低的父结点"就是"x的后继结点"。  
12.     BSTNode<T> y = x.parent;  
13.     while ((y!=null) && (x==y.right)) {  
14.         x = y;  
15.         y = y.parent;  
16.     }  
17.   
18.     return y;  
19. }  

6. 插入

插入节点的代码

[html] view plain copy

1. /*   
2.  * 将结点插入到二叉树中  
3.  *  
4.  * 参数说明：  
5.  *     tree 二叉树的  
6.  *     z 插入的结点  
7.  */  
8. private void insert(BSTree<T> bst, BSTNode<T> z) {  
9.     int cmp;  
10.     BSTNode<T> y = null;  
11.     BSTNode<T> x = bst.mRoot;  
12.   
13.     // 查找z的插入位置  
14.     while (x != null) {  
15.         y = x;  
16.         cmp = z.key.compareTo(x.key);  
17.         if (cmp < 0)  
18.             x = x.left;  
19.         else  
20.             x = x.right;  
21.     }  
22.   
23.     z.parent = y;  
24.     if (y==null)  
25.         bst.mRoot = z;  
26.     else {  
27.         cmp = z.key.compareTo(y.key);  
28.         if (cmp < 0)  
29.             y.left = z;  
30.         else  
31.             y.right = z;  
32.     }  
33. }  
34.   
35. /*   
36.  * 新建结点(key)，并将其插入到二叉树中  
37.  *  
38.  * 参数说明：  
39.  *     tree 二叉树的根结点  
40.  *     key 插入结点的键值  
41.  */  
42. public void insert(T key) {  
43.     BSTNode<T> z=new BSTNode<T>(key,null,null,null);  
44.   
45.     // 如果新建结点失败，则返回。  
46.     if (z != null)  
47.         insert(this, z);  
48. }  

7. 删除

删除节点的代码

[html] view plain copy

1. /*   
2.  * 删除结点(z)，并返回被删除的结点  
3.  *  
4.  * 参数说明：  
5.  *     bst 二叉树  
6.  *     z 删除的结点  
7.  */  
8. private BSTNode<T> remove(BSTree<T> bst, BSTNode<T> z) {  
9.     BSTNode<T> x=null;  
10.     BSTNode<T> y=null;  
11.   
12.     if ((z.left == null) || (z.right == null) )  
13.         y = z;  
14.     else  
15.         y = successor(z);  
16.   
17.     if (y.left != null)  
18.         x = y.left;  
19.     else  
20.         x = y.right;  
21.   
22.     if (x != null)  
23.         x.parent = y.parent;  
24.   
25.     if (y.parent == null)  
26.         bst.mRoot = x;  
27.     else if (y == y.parent.left)  
28.         y.parent.left = x;  
29.     else  
30.         y.parent.right = x;  
31.   
32.     if (y != z)   
33.         z.key = y.key;  
34.   
35.     return y;  
36. }  
37.   
38. /*   
39.  * 删除结点(z)，并返回被删除的结点  
40.  *  
41.  * 参数说明：  
42.  *     tree 二叉树的根结点  
43.  *     z 删除的结点  
44.  */  
45. public void remove(T key) {  
46.     BSTNode<T> z, node;   
47.   
48.     if ((z = search(mRoot, key)) != null)  
49.         if ( (node = remove(this, z)) != null)  
50.             node = null;  
51. }  

8. 打印

打印二叉查找树的代码

[html] view plain copy

1. /*  
2.  * 打印"二叉查找树"  
3.  *  
4.  * key        -- 节点的键值   
5.  * direction  --  0，表示该节点是根节点;  
6.  *               -1，表示该节点是它的父结点的左孩子;  
7.  *                1，表示该节点是它的父结点的右孩子。  
8.  */  
9. private void print(BSTNode<T> tree, T key, int direction) {  
10.   
11.     if(tree != null) {  
12.   
13.         if(direction==0)    // tree是根节点  
14.             System.out.printf("%2d is root\n", tree.key);  
15.         else                // tree是分支节点  
16.             System.out.printf("%2d is %2d's %6s child\n", tree.key, key, direction==1?"right" : "left");  
17.   
18.         print(tree.left, tree.key, -1);  
19.         print(tree.right,tree.key,  1);  
20.     }  
21. }  
22.   
23. public void print() {  
24.     if (mRoot != null)  
25.         print(mRoot, mRoot.key, 0);  
26. }  

9. 销毁

销毁二叉查找树的代码

[html] view plain copy

1. /*  
2.  * 销毁二叉树  
3.  */  
4. private void destroy(BSTNode<T> tree) {  
5.     if (tree==null)  
6.         return ;  
7.   
8.     if (tree.left != null)  
9.         destroy(tree.left);  
10.     if (tree.right != null)  
11.         destroy(tree.right);  
12.   
13.     tree=null;  
14. }  
15.   
16. public void clear() {  
17.     destroy(mRoot);  
18.     mRoot = null;  
19. }  

全部过程代码：

[html] view plain copy

1. /**  
2.  * 二叉查找树  
3.  *  
4.  * @author Anndy  
5.  */  
6.   
7. public class BSTree<T extends Comparable<T>> {  
8.   
9.     private BSTNode<T> mRoot;    // 根结点  
10.   
11.     public class BSTNode<T extends Comparable<T>> {  
12.         T key;                // 关键字(键值)  
13.         BSTNode<T> left;    // 左孩子  
14.         BSTNode<T> right;    // 右孩子  
15.         BSTNode<T> parent;    // 父结点  
16.   
17.         public BSTNode(T key, BSTNode<T> parent, BSTNode<T> left, BSTNode<T> right) {  
18.             this.key = key;  
19.             this.parent = parent;  
20.             this.left = left;  
21.             this.right = right;  
22.         }  
23.   
24.         public T getKey() {  
25.             return key;  
26.         }  
27.   
28.         public String toString() {  
29.             return "key:"+key;  
30.         }  
31.     }  
32.   
33.     public BSTree() {  
34.         mRoot=null;  
35.     }  
36.   
37.     /*  
38.      * 前序遍历"二叉树"  
39.      */  
40.     private void preOrder(BSTNode<T> tree) {  
41.         if(tree != null) {  
42.             System.out.print(tree.key+" ");  
43.             preOrder(tree.left);  
44.             preOrder(tree.right);  
45.         }  
46.     }  
47.   
48.     public void preOrder() {  
49.         preOrder(mRoot);  
50.     }  
51.   
52.     /*  
53.      * 中序遍历"二叉树"  
54.      */  
55.     private void inOrder(BSTNode<T> tree) {  
56.         if(tree != null) {  
57.             inOrder(tree.left);  
58.             System.out.print(tree.key+" ");  
59.             inOrder(tree.right);  
60.         }  
61.     }  
62.   
63.     public void inOrder() {  
64.         inOrder(mRoot);  
65.     }  
66.   
67.   
68.     /*  
69.      * 后序遍历"二叉树"  
70.      */  
71.     private void postOrder(BSTNode<T> tree) {  
72.         if(tree != null)  
73.         {  
74.             postOrder(tree.left);  
75.             postOrder(tree.right);  
76.             System.out.print(tree.key+" ");  
77.         }  
78.     }  
79.   
80.     public void postOrder() {  
81.         postOrder(mRoot);  
82.     }  
83.   
84.   
85.     /*  
86.      * (递归实现)查找"二叉树x"中键值为key的节点  
87.      */  
88.     private BSTNode<T> search(BSTNode<T> x, T key) {  
89.         if (x==null)  
90.             return x;  
91.   
92.         int cmp = key.compareTo(x.key);  
93.         if (cmp < 0)  
94.             return search(x.left, key);  
95.         else if (cmp > 0)  
96.             return search(x.right, key);  
97.         else  
98.             return x;  
99.     }  
100.   
101.     public BSTNode<T> search(T key) {  
102.         return search(mRoot, key);  
103.     }  
104.   
105.     /*  
106.      * (非递归实现)查找"二叉树x"中键值为key的节点  
107.      */  
108.     private BSTNode<T> iterativeSearch(BSTNode<T> x, T key) {  
109.         while (x!=null) {  
110.             int cmp = key.compareTo(x.key);  
111.   
112.             if (cmp < 0)   
113.                 x = x.left;  
114.             else if (cmp > 0)   
115.                 x = x.right;  
116.             else  
117.                 return x;  
118.         }  
119.   
120.         return x;  
121.     }  
122.   
123.     public BSTNode<T> iterativeSearch(T key) {  
124.         return iterativeSearch(mRoot, key);  
125.     }  
126.   
127.     /*   
128.      * 查找最小结点：返回tree为根结点的二叉树的最小结点。  
129.      */  
130.     private BSTNode<T> minimum(BSTNode<T> tree) {  
131.         if (tree == null)  
132.             return null;  
133.   
134.         while(tree.left != null)  
135.             tree = tree.left;  
136.         return tree;  
137.     }  
138.   
139.     public T minimum() {  
140.         BSTNode<T> p = minimum(mRoot);  
141.         if (p != null)  
142.             return p.key;  
143.   
144.         return null;  
145.     }  
146.        
147.     /*   
148.      * 查找最大结点：返回tree为根结点的二叉树的最大结点。  
149.      */  
150.     private BSTNode<T> maximum(BSTNode<T> tree) {  
151.         if (tree == null)  
152.             return null;  
153.   
154.         while(tree.right != null)  
155.             tree = tree.right;  
156.         return tree;  
157.     }  
158.   
159.     public T maximum() {  
160.         BSTNode<T> p = maximum(mRoot);  
161.         if (p != null)  
162.             return p.key;  
163.   
164.         return null;  
165.     }  
166.   
167.     /*   
168.      * 找结点(x)的后继结点。即，查找"二叉树中数据值大于该结点"的"最小结点"。  
169.      */  
170.     public BSTNode<T> successor(BSTNode<T> x) {  
171.         // 如果x存在右孩子，则"x的后继结点"为 "以其右孩子为根的子树的最小结点"。  
172.         if (x.right != null)  
173.             return minimum(x.right);  
174.   
175.         // 如果x没有右孩子。则x有以下两种可能：  
176.         // (01) x是"一个左孩子"，则"x的后继结点"为 "它的父结点"。  
177.         // (02) x是"一个右孩子"，则查找"x的最低的父结点，并且该父结点要具有左孩子"，找到的这个"最低的父结点"就是"x的后继结点"。  
178.         BSTNode<T> y = x.parent;  
179.         while ((y!=null) && (x==y.right)) {  
180.             x = y;  
181.             y = y.parent;  
182.         }  
183.   
184.         return y;  
185.     }  
186.        
187.     /*   
188.      * 找结点(x)的前驱结点。即，查找"二叉树中数据值小于该结点"的"最大结点"。  
189.      */  
190.     public BSTNode<T> predecessor(BSTNode<T> x) {  
191.         // 如果x存在左孩子，则"x的前驱结点"为 "以其左孩子为根的子树的最大结点"。  
192.         if (x.left != null)  
193.             return maximum(x.left);  
194.   
195.         // 如果x没有左孩子。则x有以下两种可能：  
196.         // (01) x是"一个右孩子"，则"x的前驱结点"为 "它的父结点"。  
197.         // (01) x是"一个左孩子"，则查找"x的最低的父结点，并且该父结点要具有右孩子"，找到的这个"最低的父结点"就是"x的前驱结点"。  
198.         BSTNode<T> y = x.parent;  
199.         while ((y!=null) && (x==y.left)) {  
200.             x = y;  
201.             y = y.parent;  
202.         }  
203.   
204.         return y;  
205.     }  
206.   
207.     /*   
208.      * 将结点插入到二叉树中  
209.      *  
210.      * 参数说明：  
211.      *     tree 二叉树的  
212.      *     z 插入的结点  
213.      */  
214.     private void insert(BSTree<T> bst, BSTNode<T> z) {  
215.         int cmp;  
216.         BSTNode<T> y = null;  
217.         BSTNode<T> x = bst.mRoot;  
218.   
219.         // 查找z的插入位置  
220.         while (x != null) {  
221.             y = x;  
222.             cmp = z.key.compareTo(x.key);  
223.             if (cmp < 0)  
224.                 x = x.left;  
225.             else  
226.                 x = x.right;  
227.         }  
228.   
229.         z.parent = y;  
230.         if (y==null)  
231.             bst.mRoot = z;  
232.         else {  
233.             cmp = z.key.compareTo(y.key);  
234.             if (cmp < 0)  
235.                 y.left = z;  
236.             else  
237.                 y.right = z;  
238.         }  
239.     }  
240.   
241.     /*   
242.      * 新建结点(key)，并将其插入到二叉树中  
243.      *  
244.      * 参数说明：  
245.      *     tree 二叉树的根结点  
246.      *     key 插入结点的键值  
247.      */  
248.     public void insert(T key) {  
249.         BSTNode<T> z=new BSTNode<T>(key,null,null,null);  
250.   
251.         // 如果新建结点失败，则返回。  
252.         if (z != null)  
253.             insert(this, z);  
254.     }  
255.   
256.     /*   
257.      * 删除结点(z)，并返回被删除的结点  
258.      *  
259.      * 参数说明：  
260.      *     bst 二叉树  
261.      *     z 删除的结点  
262.      */  
263.     private BSTNode<T> remove(BSTree<T> bst, BSTNode<T> z) {  
264.         BSTNode<T> x=null;  
265.         BSTNode<T> y=null;  
266.   
267.         if ((z.left == null) || (z.right == null) )  
268.             y = z;  
269.         else  
270.             y = successor(z);  
271.   
272.         if (y.left != null)  
273.             x = y.left;  
274.         else  
275.             x = y.right;  
276.   
277.         if (x != null)  
278.             x.parent = y.parent;  
279.   
280.         if (y.parent == null)  
281.             bst.mRoot = x;  
282.         else if (y == y.parent.left)  
283.             y.parent.left = x;  
284.         else  
285.             y.parent.right = x;  
286.   
287.         if (y != z)   
288.             z.key = y.key;  
289.   
290.         return y;  
291.     }  
292.   
293.     /*   
294.      * 删除结点(z)，并返回被删除的结点  
295.      *  
296.      * 参数说明：  
297.      *     tree 二叉树的根结点  
298.      *     z 删除的结点  
299.      */  
300.     public void remove(T key) {  
301.         BSTNode<T> z, node;   
302.   
303.         if ((z = search(mRoot, key)) != null)  
304.             if ( (node = remove(this, z)) != null)  
305.                 node = null;  
306.     }  
307.   
308.     /*  
309.      * 销毁二叉树  
310.      */  
311.     private void destroy(BSTNode<T> tree) {  
312.         if (tree==null)  
313.             return ;  
314.   
315.         if (tree.left != null)  
316.             destroy(tree.left);  
317.         if (tree.right != null)  
318.             destroy(tree.right);  
319.   
320.         tree=null;  
321.     }  
322.   
323.     public void clear() {  
324.         destroy(mRoot);  
325.         mRoot = null;  
326.     }  
327.   
328.     /*  
329.      * 打印"二叉查找树"  
330.      *  
331.      * key        -- 节点的键值   
332.      * direction  --  0，表示该节点是根节点;  
333.      *               -1，表示该节点是它的父结点的左孩子;  
334.      *                1，表示该节点是它的父结点的右孩子。  
335.      */  
336.     private void print(BSTNode<T> tree, T key, int direction) {  
337.   
338.         if(tree != null) {  
339.   
340.             if(direction==0)    // tree是根节点  
341.                 System.out.printf("%2d is root\n", tree.key);  
342.             else                // tree是分支节点  
343.                 System.out.printf("%2d is %2d's %6s child\n", tree.key, key, direction==1?"right" : "left");  
344.   
345.             print(tree.left, tree.key, -1);  
346.             print(tree.right,tree.key,  1);  
347.         }  
348.     }  
349.   
350.     public void print() {  
351.         if (mRoot != null)  
352.             print(mRoot, mRoot.key, 0);  
353.     }  
354. }  

测试代码：

[html] view plain copy

1. package com.struction;  
2.   
3. /**  
4.  * Java 语言: 二叉查找树  
5.  *  
6.  * @author Anndy  
7.  */  
8. public class BSTreeTest {  
9.   
10.     private static final int arr[] = {1,5,4,3,2,6};  
11.   
12.     public static void main(String[] args) {  
13.         int i, ilen;  
14.         BSTree<Integer> tree=new BSTree<Integer>();  
15.   
16.         System.out.print("== 依次添加: ");  
17.         ilen = arr.length;  
18.         for(i=0; i<ilen; i++) {  
19.             System.out.print(arr[i]+" ");  
20.             tree.insert(arr[i]);  
21.         }  
22.   
23.         System.out.print("\n== 前序遍历: ");  
24.         tree.preOrder();  
25.   
26.         System.out.print("\n== 中序遍历: ");  
27.         tree.inOrder();  
28.   
29.         System.out.print("\n== 后序遍历: ");  
30.         tree.postOrder();  
31.         System.out.println();  
32.   
33.         System.out.println("== 最小值: "+ tree.minimum());  
34.         System.out.println("== 最大值: "+ tree.maximum());  
35.         System.out.println("== 树的详细信息: ");  
36.         tree.print();  
37.   
38.         System.out.print("\n== 删除根节点: "+ arr[3]);  
39.         tree.remove(arr[3]);  
40.   
41.         System.out.print("\n== 中序遍历: ");  
42.         tree.inOrder();  
43.         System.out.println();  
44.   
45.         // 销毁二叉树  
46.         tree.clear();  
47.     }  
48. }  

运行结果：

[html] view plain copy

1. == 依次添加: 1 5 4 3 2 6   
2. == 前序遍历: 1 5 4 3 2 6   
3. == 中序遍历: 1 2 3 4 5 6   
4. == 后序遍历: 2 3 4 6 5 1   
5. == 最小值: 1  
6. == 最大值: 6  
7. == 树的详细信息:   
8.  1 is root  
9.  5 is  1's  right child  
10.  4 is  5's   left child  
11.  3 is  4's   left child  
12.  2 is  3's   left child  
13.  6 is  5's  right child  
14.   
15. == 删除根节点: 3  
16. == 中序遍历: 1 2 4 5 6   

下面对测试程序的流程进行分析！

(1) 新建"二叉查找树"root。

(2) 向二叉查找树中依次插入1,5,4,3,2,6 。如下图所示：

(3) 遍历和查找

插入1,5,4,3,2,6之后，得到的二叉查找树如下：

前序遍历结果: 1 5 4 3 2 6
中序遍历结果: 1 2 3 4 5 6
后序遍历结果: 2 3 4 6 5 1
最小值是1，而最大值是6。

(4) 删除节点3。如下图所示：

(5) 重新遍历该二叉查找树。

中序遍历结果: 1 2 4 5 6