二叉查找树（五）

　　接上一篇，继续讲二叉查找树的操作，之前的博客都讲得差不多了，本篇就讲一下删除操作，以及求最矮公共父结点（LCA：lowest common ancestor）的操作吧。

• 删除

　　将一个结点从二叉查找树中删除之后，剩下的结点可能会不满足二叉查找树的性质，因此，在删除结点之后要对树进行调整，使其满足二叉查找树的性质。根据结点的孩子的数量，将删除操作分为三种情况，我们记要删除的结点为z，实际上删除的结点为y。

　　1. z结点没有孩子。

　　如下图a所示，我们要删除值为13的结点，因为结点没有孩子，所以删除之后不会影响到二叉树的整体性质，也就是说，直接将13这个结点删除即可，如图a所示，从左边的二叉树删除13这个点之后变到右边的二叉树。

 　　2. z结点有一个孩子。

　　如下图b所示，要删除的值为16的结点有一个孩子，而且是右孩子，那么从图上来看，如果，我们将16去掉，然后把以20为结点的子树作为15的右子树，那么整棵树还是符合二叉查找树的性质的，因此，有一个孩子的结点的删除操作，就是要将其孩子作为其父结点的孩子即可。如图b所示。

 　　3. z结点有两个孩子。

　　如下图c所示，要删除的值为5的结点，有两个孩子，删除之后肯定整棵树就不符合二叉查找树的性质了，因此要进行调整，我们发现，将5的后继，值为6的结点来放到5的位置，然后将6的孩子7作为6的父结点10的孩子，如下图c所示，我们要删除的是z结点，而我们实际要删除y结点，并替换z结点。这里需要注意的一点是，如果一个结点有右孩子，则该结点的后继，至多有一个子女，而且是右孩子。因为假如该结点的后继有左孩子和右孩子，那么其左孩子的值肯定是介于该结点和其后继之间的，那么按照二叉查找树的性质，这个左孩子就应该是该结点的后继，所以，这与原先的后继相互矛盾，因此，结论成立。

　　好了，分析完了删除的三种情况，我们来完成我们的程序吧。

 1 /**
 2      * 删除二叉查找树中的结点z
 3      * @author Alfred
 4      * @param z 要删除的结点
 5      * @return 删除或者替换的结点
 6      */
 7     public TreeNode treeDelete(TreeNode z){
 8         TreeNode x = null, y = null;
 9         if(z.getLeft() == null || z.getRight() == null){
10             //对应第1和第2种情况
11             y = z;
12         }else{
13             //对应第3种情况
14             y = treeSuccessor(z);
15         }
16         //将x置为y的非null子女，或者当y无子女时置为null
17         if(y.getLeft() != null){
18             x = y.getLeft();
19         }else{
20             x = y.getRight();
21         }
22         //通过修改x和y的父结点的引用，将y删除
23         if(x != null){
24             x.setParent(y.getParent());
25         }
26         if(y.getParent() == null){
27             //x成为树根
28             rootNode = x;
29         }else if(y == y.getParent().getLeft()){
30             //y是其父结点的左孩子
31             y.getParent().setLeft(x);
32         }else{
33             //y是其父结点的右孩子
34             y.getParent().setRight(x);
35         }
36         //如果y和z不是同一个结点，说明是第3种情况
37         if(y != z){
38             //内容替换
39             z.setKey(y.getKey());
40             z.setDataNum(y.getDataNum());
41         }
42         return y;
43     }

　　上面的程序完整的搞定了上面分析的三种情况。

• LCA

　　LCA问题对于二叉查找树来说是非常简单的。因为二叉查找树满足其特有的性质。给定树中的两个结点x和y，求其最低公共父结点。我们把这个算法分为三种情况。对于一棵二叉查找树来说：

　　1. 如果x和y分别位于某结点z的左右子树上，那么结点z就是x和y的lca。

　　2. 如果x和y位于某结点z的左子树或者右子树上，那么x和y的lca也必然位于其所处的左子树或者右子树上。

　　3. 如果x或者y中，有一个结点是另外一个结点的父结点，那么lca就是它们中的父结点。即如果有一个点和某结点重合，则重合的点就是lca。

　　那么，我们就从根结点开始，按照从上往下的顺序查找lca吧，比较根结点与两结点的关系，然后再进行下一步的操作。代码如下：

 1 /**
 2      * 求两个结点的最低公共父结点
 3      * @author Alfred
 4      * @param x 结点
 5      * @param y 结点
 6      * @return 最低公共父结点
 7      */
 8     public TreeNode lca(TreeNode x, TreeNode y){
 9         TreeNode tmpNode = rootNode;
10         //获取两个key值
11         int xKey = x.getKey();
12         int yKey = y.getKey();
13         //给两个元素按从小到大排下序，使得x<y
14         if(xKey > yKey){
15             int tmpKey = xKey;
16             xKey = yKey;
17             yKey = tmpKey;
18         }
19         while(true){
20             if(tmpNode.getKey() < xKey){
21                 //这种情况下，lca在其右子树上
22                 tmpNode = tmpNode.getRight();
23             }else if(tmpNode.getKey() > yKey){
24                 //这种情况下，lca在其左子树上
25                 tmpNode = tmpNode.getLeft();
26             }else{
27                 return tmpNode;
28             }
29         }
30     }

　　代码比较简单，就是按照上面的三种情况按照从上到下的顺序来分类处理的。其他还有一些lca算法，如离线算法(Tarjan)和在线算法(RMQ)等，暂时先不讨论了，以后有时间了再补上吧。为了方便想学习的童鞋来测试，我把整个代码就贴到下面了（木有找到更好地方法来分享。。）。

TreeNode.java

 1 package com.alfred.bstree;
 2 
 3 /**
 4  * 二叉查找树结点
 5  * @author Alfred
 6  */
 7 public class TreeNode {
 8     //key值
 9     private int key;
10     //记录相同的key值的结点个数
11     private int dataNum;
12     //下面三个大家都懂得！
13     private TreeNode parent;
14     private TreeNode left;
15     private TreeNode right;
16     public TreeNode(int key){
17         this.key = key;
18         this.dataNum = 1;
19     }
20     public String toString(){
21         return ""+key+"*"+dataNum+"  ";
22     }
23     /**
24      * 偷个懒...自加方法
25      * @author Alfred
26      */
27     public void incNumByOne(){
28         this.dataNum++;
29     }
30     
31     /**
32      * @return the key
33      */
34     public int getKey() {
35         return key;
36     }
37     /**
38      * @param key the key to set
39      */
40     public void setKey(int key) {
41         this.key = key;
42     }
43     /**
44      * @return the dataNum
45      */
46     public int getDataNum() {
47         return dataNum;
48     }
49     /**
50      * @param dataNum the dataNum to set
51      */
52     public void setDataNum(int dataNum) {
53         this.dataNum = dataNum;
54     }
55     /**
56      * @return the parent
57      */
58     public TreeNode getParent() {
59         return parent;
60     }
61     /**
62      * @param parent the parent to set
63      */
64     public void setParent(TreeNode parent) {
65         this.parent = parent;
66     }
67     /**
68      * @return the left
69      */
70     public TreeNode getLeft() {
71         return left;
72     }
73     /**
74      * @param left the left to set
75      */
76     public void setLeft(TreeNode left) {
77         this.left = left;
78     }
79     /**
80      * @return the right
81      */
82     public TreeNode getRight() {
83         return right;
84     }
85     /**
86      * @param right the right to set
87      */
88     public void setRight(TreeNode right) {
89         this.right = right;
90     }
91 }

BSTree.java

  1 package com.alfred.bstree;
  2 
  3 import java.util.LinkedList;
  4 import java.util.List;
  5 import java.util.Queue;
  6 import java.util.Random;
  7 import java.util.Stack;
  8 
  9 /**
 10  * 二叉查找树
 11  * @author Alfred
 12  */
 13 public class BSTree {
 14     //随机化的构造二叉查找树
 15     private Random rand = null;
 16     //根结点
 17     private TreeNode rootNode = null;
 18     
 19     /**
 20      * 以int数组A来创建二叉查找树
 21      * @param A int数组
 22      */
 23     public BSTree(int[] A){
 24         rand = new Random();
 25         createBSTree(A);
 26     }
 27     
 28     /**
 29      * 创建二叉查找树
 30      * @param A int数组
 31      */
 32     private void createBSTree(int[] A){
 33         //先构建一个存储数组下标的List
 34         List<Integer> index = new LinkedList<Integer>();
 35         int i = 0;
 36         for(i = 0; i < A.length; i++){
 37             index.add(i);
 38         }
 39         //随机构造二叉树
 40         for(i = 0; i < A.length; i++){
 41             int j = 0;
 42             if(index.size() > 1){
 43                 //随机产生一个数组下标值
 44                 j = rand.nextInt(index.size() - 1);
 45             }
 46             //插入二叉树
 47             TreeInsert(A[index.get(j)]);
 48             //移除下标
 49             index.remove(j);
 50         }
 51     }
 52     
 53     /**
 54      * 插入一个整数
 55      * @param z 整数
 56      */
 57     public void TreeInsert(int z){
 58         TreeNode parentNode = null;
 59         TreeNode searchNode = rootNode;
 60         TreeNode insertNode = new TreeNode(z);
 61         //while循环找到要插入的点的父结点
 62         while(searchNode != null){
 63             parentNode = searchNode;
 64             if(insertNode.getKey() < searchNode.getKey()){
 65                 searchNode = searchNode.getLeft();
 66             }else if(insertNode.getKey() == searchNode.getKey()){
 67                 //如果是key值相同的话，直接插入，偷懒在这里...
 68                 searchNode.incNumByOne();
 69                 return;
 70             }else{
 71                 searchNode = searchNode.getRight();
 72             }
 73         }
 74         
 75         insertNode.setParent(parentNode);
 76         if(parentNode == null){
 77             rootNode = insertNode;
 78         }else if(insertNode.getKey() < parentNode.getKey()){
 79             //插入左结点
 80             parentNode.setLeft(insertNode);
 81         }else if(insertNode.getKey() == parentNode.getKey()){
 82             //因为上面插入了，所以这里就不会执行了。
 83             parentNode.incNumByOne();
 84             System.out.println("this is not supposed to be executed.");
 85         }else{
 86             //插入右结点
 87             parentNode.setRight(insertNode);
 88         }
 89     }
 90     
 91     /**
 92      * 递归前序遍历以x为根的二叉树
 93      * @author Alfred
 94      * @param x 根结点
 95      */
 96     public void preOrderTreeWalk(TreeNode x){
 97         if(x != null){
 98             System.out.print(x);//访问形式为打印输出一下
 99             preOrderTreeWalk(x.getLeft());
100             preOrderTreeWalk(x.getRight());
101         }
102     }
103     
104     public void preOrderTreeWalk(){
105         preOrderTreeWalk(rootNode);
106     }
107     
108     /**
109      * 非递归前序遍历以x为根结点的二叉树
110      * @author Alfred
111      * @param x 根结点
112      */
113     public void preOrderTreeWalkNonrecursive1(TreeNode x){
114         //借助栈来实现。
115         Stack<TreeNode> stack = new Stack<TreeNode>();
116         while(x != null || !stack.empty()){
117             if(x != null){
118                 System.out.print(x);//遍历输出
119                 stack.push(x);//压栈
120                 x = x.getLeft();
121             }else{
122                 x = stack.pop();//出栈
123                 x = x.getRight();
124             }
125         }
126     }
127     
128     /**
129      * 非递归前序遍历以x为根结点的二叉树
130      * @author Alfred
131      * @param x 根结点
132      */
133     public void preOrderTreeWalkNonrecursive2(TreeNode x){
134         Stack<TreeNode> stack = new Stack<TreeNode>();
135         if(x != null){
136             stack.push(x);
137             while(!stack.empty()){
138                 TreeNode tmpNode = stack.pop();
139                 System.out.print(tmpNode);//遍历输出
140                 if(tmpNode.getRight() != null){
141                     stack.push(tmpNode.getRight());
142                 }
143                 if(tmpNode.getLeft() != null){
144                     stack.push(tmpNode.getLeft());
145                 }
146             }
147         }
148     }
149     
150     public void preOrderTreeWalkNonrecursive(){
151         System.out.println("方法1：");
152         preOrderTreeWalkNonrecursive1(rootNode);
153         System.out.println("\n方法2：");
154         preOrderTreeWalkNonrecursive2(rootNode);
155     }
156     
157     /**
158      * 递归中序遍历以x为根的二叉树
159      * @author Alfred
160      * @param x 根结点
161      */
162     public void inOrderTreeWalk(TreeNode x){
163         if(x != null){
164             inOrderTreeWalk(x.getLeft());
165             System.out.print(x);
166             inOrderTreeWalk(x.getRight());
167         }
168     }
169     
170     public void inOrderTreeWalk(){
171         inOrderTreeWalk(rootNode);
172     }
173     
174     /**
175      * 非递归中序遍历以x为根结点的二叉树
176      * @author Alfred
177      * @param x 根结点
178      */
179     public void inOrderTreeWalkNonrecursive(TreeNode x){
180         Stack<TreeNode> stack = new Stack<TreeNode>();
181         while(x != null || !stack.empty()){
182             if(x != null){
183                 stack.push(x);
184                 x = x.getLeft();
185             }else{
186                 x = stack.pop();
187                 System.out.print(x);//遍历输出
188                 x = x.getRight();
189             }
190         }
191     }
192     
193     public void inOrderTreeWalkNonrecursive(){
194         inOrderTreeWalkNonrecursive(rootNode);
195     }
196     
197     /**
198      * 递归后序遍历以x为根的二叉树
199      * @author Alfred
200      * @param x 根结点
201      */
202     public void postOrderTreeWalk(TreeNode x){
203         if(x != null){
204             postOrderTreeWalk(x.getLeft());
205             postOrderTreeWalk(x.getRight());
206             System.out.print(x);
207         }
208     }
209     
210     public void postOrderTreeWalk(){
211         postOrderTreeWalk(rootNode);
212     }
213     /**
214      * 非递归后序遍历以x为根结点的二叉树
215      * @author Alfred
216      * @param x 根结点
217      */
218     public void postOrderTreeWalkNonrecursive1(TreeNode x){
219         Stack<TreeNode> stack = new Stack<TreeNode>();
220         TreeNode prev = null;
221         TreeNode curr = null;
222         if(x != null){
223             stack.push(x);
224         }
225         while(!stack.empty()){
226             curr = stack.peek();
227             if(prev == null || prev.getLeft() == curr || prev.getRight() == curr){
228                 if(curr.getLeft() != null){
229                     stack.push(curr.getLeft());//压左孩子
230                 }else if(curr.getRight() != null){
231                     stack.push(curr.getRight());//压右孩子
232                 }
233             }else if(curr.getLeft() == prev){
234                 if(curr.getRight() != null){
235                     stack.push(curr.getRight());//压右孩子
236                 }
237             }else{
238                 System.out.print(curr);//遍历输出
239                 stack.pop();
240             }
241             prev = curr;
242         }
243     }
244     
245     /**
246      * 非递归后序遍历以x为根结点的二叉树
247      * @author Alfred
248      * @param x 根结点
249      */
250     public void postOrderTreeWalkNonrecursive2(TreeNode x){
251         Stack<TreeNode> stack = new Stack<TreeNode>();
252         Stack<TreeNode> output = new Stack<TreeNode>();
253         TreeNode curr = null;
254         if(x != null){
255             stack.push(x);
256         }
257         while(!stack.empty()){
258             curr = stack.pop();
259             output.push(curr);//存放到输出地栈里面
260             if(curr.getLeft() != null){
261                 stack.push(curr.getLeft());//压左孩子
262             }
263             if(curr.getRight() != null){
264                 stack.push(curr.getRight());//压右孩子
265             }
266         }
267         while(!output.empty()){
268             TreeNode tmpNode = output.pop();
269             System.out.print(tmpNode);//打印输出
270         }
271     }
272     
273     public void postOrderTreeWalkNonrecursive(){
274         System.out.println("方法1：");
275         postOrderTreeWalkNonrecursive1(rootNode);
276         System.out.println("\n方法2：");
277         postOrderTreeWalkNonrecursive2(rootNode);
278     }
279     /**
280      * 层序遍历二叉树
281      * @author Alfred
282      * @param x 根结点
283      */
284     public void levelOrderTreeWalk(TreeNode x){
285         Queue<TreeNode> queue = new LinkedList<TreeNode>();
286         TreeNode tmpNode = null;
287         if(x != null){
288             queue.offer(x);
289         }
290         while(!queue.isEmpty()){
291             tmpNode = queue.poll();
292             System.out.print(tmpNode);//打印输出
293             if(tmpNode.getLeft() != null){
294                 queue.offer(tmpNode.getLeft());//左孩子入队
295             }
296             if(tmpNode.getRight() != null){
297                 queue.offer(tmpNode.getRight());//右孩子入队
298             }
299         }
300     }
301     public void levelOrderTreeWalk(){
302         levelOrderTreeWalk(rootNode);
303     }
304     
305     
306     /**
307      * 查找以x为根结点的树中key的值为k的结点，返回找到的结点或者null
308      * @author Alfred
309      * @param x 根结点
310      * @param k 要查找的整数
311      * @return 找到的结点或者null
312      */
313     private TreeNode treeSearch(TreeNode x, int k){
314 //        System.out.println("treeSearch:"+x);
315         if(x == null || k == x.getKey()){
316             return x;
317         }
318         if(k < x.getKey()){
319             return treeSearch(x.getLeft(), k);//查左子树
320         }else{
321             return treeSearch(x.getRight(), k);//查右子树
322         }
323     }
324     /**
325      * 非递归地查找以x为根结点的树中key的值为k的结点，返回找到的结点或者null
326      * @author Alfred
327      * @param x 根结点
328      * @param k 要查找的整数
329      * @return 找到的结点或者null
330      */
331     private TreeNode treeSearchNonrecursive(TreeNode x, int k){
332         while(x != null && k != x.getKey()){
333             if(k < x.getKey()){
334                 x = x.getLeft();
335             }else{
336                 x = x.getRight();
337             }
338         }
339         return x;
340     }
341     
342     public TreeNode treeSearch(int k){
343         return treeSearch(rootNode, k);
344     }
345     public TreeNode treeSearchNonrecursive(int k){
346         return treeSearchNonrecursive(rootNode, k);
347     }
348     /**
349      * 找以x为根结点的二叉查找树中的最小值
350      * @author Alfred
351      * @param x 根结点
352      * @return 最小值结点或者null
353      */
354     public TreeNode treeMin(TreeNode x){
355         while(x.getLeft() != null){
356             x = x.getLeft();
357         }
358         return x;
359     }
360     
361     public TreeNode treeMin(){
362         return treeMin(rootNode);
363     }
364     /**
365      * 找以x为根结点的二叉查找树中的最大值
366      * @author Alfred
367      * @param x 根结点
368      * @return 最大值结点或者null
369      */
370     public TreeNode treeMax(TreeNode x){
371         while(x.getRight() != null){
372             x = x.getRight();
373         }
374         return x;
375     }
376     
377     public TreeNode treeMax(){
378         return treeMax(rootNode);
379     }
380     /**
381      * 找结点x的后继结点
382      * @author Alfred
383      * @param x 结点
384      * @return x的后继结点或者null
385      */
386     public TreeNode treeSuccessor(TreeNode x){
387         //第一种情况
388         if(x.getRight() != null){
389             return treeMin(x.getRight());
390         }
391         //第二种情况
392         TreeNode tmpNode = x.getParent();
393         while(tmpNode != null && x == tmpNode.getRight()){
394             x = tmpNode;
395             tmpNode = tmpNode.getParent();
396         }
397         return tmpNode;
398     }
399     
400     /**
401      * 找结点x的前趋结点
402      * @author Alfred
403      * @param x 结点
404      * @return x的前趋结点或者null
405      */
406     public TreeNode treePredecessor(TreeNode x){
407         //第一种情况
408         if(x.getLeft() != null){
409             return treeMax(x.getLeft());
410         }
411         //第二种情况
412         TreeNode tmpNode = x.getParent();
413         while(tmpNode != null && x == tmpNode.getLeft()){
414             x = tmpNode;
415             tmpNode = tmpNode.getParent();
416         }
417         return tmpNode;
418     }
419     
420     /**
421      * 删除二叉查找树中的结点z
422      * @author Alfred
423      * @param z 要删除的结点
424      * @return 删除或者替换的结点
425      */
426     public TreeNode treeDelete(TreeNode z){
427         TreeNode x = null, y = null;
428         if(z.getLeft() == null || z.getRight() == null){
429             //对应第1和第2种情况
430             y = z;
431         }else{
432             //对应第3种情况
433             y = treeSuccessor(z);
434         }
435         //将x置为y的非null子女，或者当y无子女时置为null
436         if(y.getLeft() != null){
437             x = y.getLeft();
438         }else{
439             x = y.getRight();
440         }
441         //通过修改x和y的父结点的引用，将y删除
442         if(x != null){
443             x.setParent(y.getParent());
444         }
445         if(y.getParent() == null){
446             //x成为树根
447             rootNode = x;
448         }else if(y == y.getParent().getLeft()){
449             //y是其父结点的左孩子
450             y.getParent().setLeft(x);
451         }else{
452             //y是其父结点的右孩子
453             y.getParent().setRight(x);
454         }
455         //如果y和z不是同一个结点，说明是第3种情况
456         if(y != z){
457             //内容替换
458             z.setKey(y.getKey());
459             z.setDataNum(y.getDataNum());
460         }
461         return y;
462     }
463     
464     /**
465      * 求两个结点的最低公共父结点
466      * @author Alfred
467      * @param x 结点
468      * @param y 结点
469      * @return 最低公共父结点
470      */
471     public TreeNode lca(TreeNode x, TreeNode y){
472         TreeNode tmpNode = rootNode;
473         //获取两个key值
474         int xKey = x.getKey();
475         int yKey = y.getKey();
476         //给两个元素按从小到大排下序，使得x<y
477         if(xKey > yKey){
478             int tmpKey = xKey;
479             xKey = yKey;
480             yKey = tmpKey;
481         }
482         while(true){
483             if(tmpNode.getKey() < xKey){
484                 //这种情况下，lca在其右子树上
485                 tmpNode = tmpNode.getRight();
486             }else if(tmpNode.getKey() > yKey){
487                 //这种情况下，lca在其左子树上
488                 tmpNode = tmpNode.getLeft();
489             }else{
490                 return tmpNode;
491             }
492         }
493     }
494 }

TestMain.java

 1 package com.alfred.bstree;
 2 
 3 public class testMain {
 4 
 5     public static void main(String[] args) {
 6         int[] A = new int[]{15,6,18,3,7,17,20,2,4,13,9,3,18,8,8,8,8,8};
 7         BSTree bsTree = new BSTree(A);
 8         System.out.println("前序遍历递归方法：");
 9         bsTree.preOrderTreeWalk();
10         System.out.println("\n前序遍历非递归方法：");
11         bsTree.preOrderTreeWalkNonrecursive();
12         System.out.println("\n中序遍历递归方法：");
13         bsTree.inOrderTreeWalk();
14         System.out.println("\n中序遍历非递归方法：");
15         bsTree.inOrderTreeWalkNonrecursive();
16         System.out.println("\n后序遍历递归方法：");
17         bsTree.postOrderTreeWalk();
18         System.out.println("\n后序遍历非递归方法：");
19         bsTree.postOrderTreeWalkNonrecursive();
20         System.out.println("\n层序遍历方法：");
21         bsTree.levelOrderTreeWalk();
22         
23         System.out.println("\n递归查找：");
24         System.out.println(bsTree.treeSearch(8));
25         System.out.println("非递归查找：");
26         System.out.println(bsTree.treeSearchNonrecursive(8));
27         
28         System.out.println("\n最大值：");
29         System.out.println(bsTree.treeMax());
30         System.out.println("最小值：");
31         System.out.println(bsTree.treeMin());
32         System.out.println("8的后继：");
33         System.out.println(bsTree.treeSuccessor(bsTree.treeSearch(8)));
34         System.out.println("8的前驱：");
35         System.out.println(bsTree.treePredecessor(bsTree.treeSearch(8)));
36         System.out.println("\n最大最小值的LCA：");
37         System.out.println(bsTree.lca(bsTree.treeMin(), bsTree.treeMax()));
38         
39         System.out.println("删除8之后：");
40         TreeNode eight = bsTree.treeSearch(8);
41         bsTree.inOrderTreeWalk();
42         System.out.println();
43         bsTree.treeDelete(eight);
44         bsTree.inOrderTreeWalk();
45     }
46 }

　　ps：关于二叉查找树的一些操作先写到这里吧，有不对的地方，请广大博友指正啊。

　　pss：画图好累啊。。转载请注明。。。