二叉查找树--查找、删除、插入（Java实现）

        二叉查找树

                 二叉查找树（Binary Search Tree），或者是一颗空树，或者是具有下列性质的二叉树：

                       1、若它的左子树不空，则其左子树上的所有结点的值均小于它根结点的值；

                       2、若它的右子树不空，则其右子树上的所有结点的值均大于它根结点的值；

                       3、它的左、右子树也分别为二叉查找树。

                                                  

                 二叉查找树是基于二叉树的，其结点数据结构定义为如下：

[java]  view plain  copy

1. /**结点数据结构*/  
2. static class BinaryNode<T>  
3. {  
4.     T data;  
5.     BinaryNode<T> left;  
6.     BinaryNode<T> right;  
7.     public BinaryNode(T data) {  
8.         this(data,null,null);  
9.     }  
10.     public BinaryNode( T data, BinaryNode<T> left, BinaryNode<T> right) {  
11.         this.data =data;  
12.         this.left = left;  
13.         this.right =right;  
14.     }  
15.     public BinaryNode()  
16.     {  
17.         data =null;  
18.         this.left = left;  
19.         this.right =right;  
20.     }  
21. }  

                 现在明白了什么是二叉查找树，那么二叉查找书的基本操作又是如何来实现的呢？                

          查找操作

                       在二叉查找树中查找x的过程如下：

                             1、若二叉树是空树，则查找失败。

                             2、若x等于根结点的数据，则查找成功，否则。

                             3、若x小于根结点的数据，则递归查找其左子树，否则。

                             4、递归查找其右子树。

                     根据上述的步骤，写出其查找操作的代码： 

[java]  view plain  copy

1. /**查找指定的元素,默认从 
2.     * 根结点出开始查询*/  
3.    public boolean contains(T t)  
4.    {  
5.       return contains(t, rootTree);  
6.          
7.    }  
8.  /**从某个结点出开始查找元素*/  
9.    public boolean contains(T t, BinaryNode<T> node)  
10.    {  
11.       if(node==null)  
12.         return false;//结点为空，查找失败  
13.       int result = t.compareTo(node.data);  
14.        if(result>0)  
15.           return contains(t,node.right);//递归查询右子树  
16.       else if(result<0)  
17.           return contains(t, node.left);//递归查询左子树    
18.       else  
19.           return true;  
20.    }  
21.     /** 
22.        这里我提供一个对二叉树最大值 
23.        最小值的搜索*/  
24.    
25.   
26.  /**找到二叉查找树中的最小值*/  
27.    public T findMin()  
28.    {  
29.       if(isEmpty())  
30.       {  
31.           System.out.println("二叉树为空");  
32.           return null;  
33.       }else  
34.        return findMin(rootTree).data;  
35.          
36.    }  
37.    /**找到二叉查找树中的最大值*/  
38.    public T findMax()  
39.    {  
40.        if(isEmpty())  
41.           {  
42.               System.out.println("二叉树为空");  
43.               return null;  
44.           }else  
45.            return findMax(rootTree).data;  
46.    }  
47.   
48. /**查询出最小元素所在的结点*/  
49.    public BinaryNode<T> findMin(BinaryNode<T> node)  
50.    {  
51.        if(node==null)  
52.            return null;  
53.        else if(node.left==null)  
54.            return node;  
55.        return findMin(node.left);//递归查找  
56.    }  
57.    /**查询出最大元素所在的结点*/  
58.    public BinaryNode<T> findMax(BinaryNode<T> node)  
59.    {  
60.        if(node!=null)  
61.        {  
62.            while(node.right!=null)  
63.                node=node.right;  
64.        }  
65.        return node;         
66.    }  

           插入操作

                     二叉树查找树b插入操作x的过程如下：

                        1、若b是空树，则直接将插入的结点作为根结点插入。

                        2、x等于b的根结点的数据的值，则直接返回，否则。

                        3、若x小于b的根结点的数据的值，则将x要插入的结点的位置改变为b的左子树，否则。

                        4、将x要出入的结点的位置改变为b的右子树。

               代码实现如下：

[java]  view plain  copy

1. /**插入元素*/  
2.    public void insert(T t)  
3.    {  
4.        rootTree = insert(t, rootTree);  
5.    }  
6. /**在某个位置开始判断插入元素*/  
7.    public BinaryNode<T> insert(T t,BinaryNode<T> node)  
8.    {  
9.        if(node==null)  
10.        {  
11.            //新构造一个二叉查找树  
12.            return new BinaryNode<T>(t, null, null);  
13.        }  
14.        int result = t.compareTo(node.data);  
15.        if(result<0)  
16.           node.left= insert(t,node.left);  
17.        else if(result>0)  
18.           node.right= insert(t,node.right);  
19.        else  
20.            ;//doNothing  
21.        return node;  
22.    }  

          删除操作

                         对于二叉查找树的删除操作（这里根据值删除，而非结点）分三种情况：

                   不过在此之前，我们应该确保根据给定的值找到了要删除的结点，如若没找到该结点

                   不会执行删除操作！

                      下面三种情况假设已经找到了要删除的结点。

                        1、如果结点为叶子结点（没有左、右子树），此时删除该结点不会玻化树的结构

                             直接删除即可，并修改其父结点指向它的引用为null.如下图:

                

                       2、如果其结点只包含左子树，或者右子树的话，此时直接删除该结点，并将其左子树

                              或者右子树设置为其父结点的左子树或者右子树即可，此操作不会破坏树结构。
                 
                           

                       3、 当结点的左右子树都不空的时候，一般的删除策略是用其右子树的最小数据

                            （容易找到）代替要删除的结点数据并递归删除该结点（此时为null），因为

                              右子树的最小结点不可能有左孩子，所以第二次删除较为容易。

                               z的左子树和右子树均不空。找到z的后继y，因为y一定没有左子树，所以可以删除y，

                              并让y的父亲节点成为y的右子树的父亲节点，并用y的值代替z的值.如图：

                    

                  删除操作源码：

[java]  view plain  copy

1. /**删除元素*/  
2.    public void remove(T t)  
3.    {  
4.        rootTree = remove(t,rootTree);  
5.    } /**在某个位置开始判断删除某个结点*/  
6.    public BinaryNode<T> remove(T t,BinaryNode<T> node)  
7.    {  
8.        if(node == null)  
9.            return node;//没有找到,doNothing  
10.        int result = t.compareTo(node.data);  
11.        if(result>0)  
12.            node.right = remove(t,node.right);  
13.        else if(result<0)  
14.            node.left = remove(t,node.left);  
15.        else if(node.left!=null&&node.right!=null)  
16.        {  
17.            node.data = findMin(node.right).data;  
18.            node.right = remove(node.data,node.right);  
19.        }  
20.        else  
21.            node = (node.left!=null)?node.left:node.right;  
22.        return node;  
23.              
24.    }  

             完整源码

[java]  view plain  copy

1. <p></p><pre name="code" class="java">package com.kiritor;  
2. /** 
3.  * Java实现二叉查找树 
4.  * @author Kiritor 
5.  * @param <T>*/  
6. public class BinarySearchTree<T extends Comparable<? super T>> {  
7.     
8.  /**结点数据结构*/  
9.  static class BinaryNode<T>  
10.     {  
11.         T data;  
12.         BinaryNode<T> left;  
13.         BinaryNode<T> right;  
14.         public BinaryNode(T data) {  
15.             this(data,null,null);  
16.         }  
17.         public BinaryNode( T data, BinaryNode<T> left, BinaryNode<T> right) {  
18.             this.data =data;  
19.             this.left = left;  
20.             this.right =right;  
21.         }  
22.         public BinaryNode()  
23.         {  
24.             data =null;  
25.             this.left = left;  
26.             this.right =right;  
27.         }  
28.     }  
29.      
30.    private BinaryNode<T> rootTree;  
31.    /**构造一颗空的二叉查找树*/  
32.    public BinarySearchTree()  
33.    {  
34.        rootTree = null;  
35.    }  
36.    /**清空二叉查找树*/  
37.    public void clear()  
38.    {  
39.        rootTree = null;  
40.    }  
41.    /**判断是否为空*/  
42.    public boolean isEmpty()  
43.    {  
44.        return rootTree == null;  
45.    }  
46.    /**查找指定的元素,默认从 
47.     * 根结点出开始查询*/  
48.    public boolean contains(T t)  
49.    {  
50.       return contains(t, rootTree);  
51.          
52.    }  
53.    /**找到二叉查找树中的最小值*/  
54.    public T findMin()  
55.    {  
56.       if(isEmpty())  
57.       {  
58.           System.out.println("二叉树为空");  
59.           return null;  
60.       }else  
61.        return findMin(rootTree).data;  
62.          
63.    }  
64.    /**找到二叉查找树中的最大值*/  
65.    public T findMax()  
66.    {  
67.        if(isEmpty())  
68.           {  
69.               System.out.println("二叉树为空");  
70.               return null;  
71.           }else  
72.            return findMax(rootTree).data;  
73.    }  
74.    /**插入元素*/  
75.    public void insert(T t)  
76.    {  
77.        rootTree = insert(t, rootTree);  
78.    }  
79.    /**删除元素*/  
80.    public void remove(T t)  
81.    {  
82.        rootTree = remove(t,rootTree);  
83.    }  
84.    /**打印二叉查找树*/  
85.    public void printTree()  
86.    {  
87.         
88.    }  
89.    /**从某个结点出开始查找元素*/  
90.    public boolean contains(T t, BinaryNode<T> node)  
91.    {  
92.       if(node==null)  
93.         return false;  
94.       int result = t.compareTo(node.data);  
95.       if(result>0)  
96.           return contains(t,node.right);  
97.       else if(result<0)  
98.           return contains(t, node.left);  
99.       else  
100.           return true;  
101.    }  
102.    /**查询出最小元素所在的结点*/  
103.    public BinaryNode<T> findMin(BinaryNode<T> node)  
104.    {  
105.        if(node==null)  
106.            return null;  
107.        else if(node.left==null)  
108.            return node;  
109.        return findMin(node.left);//递归查找  
110.    }  
111.    /**查询出最大元素所在的结点*/  
112.    public BinaryNode<T> findMax(BinaryNode<T> node)  
113.    {  
114.        if(node!=null)  
115.        {  
116.            while(node.right!=null)  
117.                node=node.right;  
118.        }  
119.        return node;      
120.    }  
121.    /**在某个位置开始判断插入元素*/  
122.    public BinaryNode<T> insert(T t,BinaryNode<T> node)  
123.    {  
124.        if(node==null)  
125.        {  
126.            //新构造一个二叉查找树  
127.            return new BinaryNode<T>(t, null, null);  
128.        }  
129.        int result = t.compareTo(node.data);  
130.        if(result<0)  
131.           node.left= insert(t,node.left);  
132.        else if(result>0)  
133.           node.right= insert(t,node.right);  
134.        else  
135.            ;//doNothing  
136.        return node;  
137.    }  
138.    /**在某个位置开始判断删除某个结点*/  
139.    public BinaryNode<T> remove(T t,BinaryNode<T> node)  
140.    {  
141.        if(node == null)  
142.            return node;//没有找到,doNothing  
143.        int result = t.compareTo(node.data);  
144.        if(result>0)  
145.            node.right = remove(t,node.right);  
146.        else if(result<0)  
147.            node.left = remove(t,node.left);  
148.        else if(node.left!=null&&node.right!=null)  
149.        {  
150.            node.data = findMin(node.right).data;  
151.            node.right = remove(node.data,node.right);  
152.        }  
153.        else  
154.            node = (node.left!=null)?node.left:node.right;  
155.        return node;  
156.              
157.    }  
158.    public BinaryNode<Integer> init()  
159.    {  
160.        BinaryNode<Integer> node3 = new BinaryNode<Integer>(3);  
161.        BinaryNode<Integer> node1 = new BinaryNode<Integer>(1);  
162.        BinaryNode<Integer> node4 = new BinaryNode<Integer>(4,node3,null);  
163.        BinaryNode<Integer> node2 = new BinaryNode<Integer>(2,node1,node4);  
164.        BinaryNode<Integer> node8 = new BinaryNode<Integer>(8);  
165.        BinaryNode<Integer> root = new BinaryNode<Integer>(6,node2,node8);  
166.        return root;  
167.    }  
168.     public void preOrder(BinaryNode node) {  
169.         if (node != null) {  
170.             System.out.print(node.data);  
171.             preOrder(node.left);  
172.             preOrder(node.right);  
173.         }  
174.     }  
175.       /*简单测试*/   
176.       public static void main(String[] args) {  
177.         BinarySearchTree  searchTree = new BinarySearchTree<>();  
178.         BinaryNode<Integer> node= searchTree.init();  
179.         searchTree.rootTree=node;  
180.         searchTree.preOrder(searchTree.rootTree);  
181.         searchTree.remove(4);  
182.         searchTree.preOrder(searchTree.rootTree);  
183.     }  
184.      
185. }