查找树ADT之二叉查找树

二叉树对学计算机的同学们来说并不陌生，今天我们就来说说二叉树的一个重要应用，就是在查找中的应用，首先要使二叉树成为二叉查找树的的主要性质是：对于树中的每个节点X,它的左子树中所有项的值小于X中的项，而它右子树中所有项的值大于X中的项，这意味着树中所有的元素是要经过排序的，因为二叉查找树的平均深度是O(logN)，所以不必担心栈空间不够用，下面是代码实现，由于要实现元素排序，所以我们实现一个Comparable接口来保证元素是有序的。
代码实现如下:

    /**
 * 
 * @author fengzi
 * 
 * @param <E>
 */
public class BinarySearchTree<E extends Comparable<? super E>>{
    private static class BinaryNode<E>{
        E element;
        BinaryNode<E> left;
        BinaryNode<E> right;

        public BinaryNode(E theElement) {
            this(theElement,null,null);
        }

        public BinaryNode(E theElement,BinaryNode<E> lt,BinaryNode<E> rt) {
            element = theElement;
            left = lt;
            right  = rt;
        }
    }

    private BinaryNode<E> root;

    public BinarySearchTree(){
        root = null;
    }

    public void makeEmpty(){
        root = null;
    }

    public boolean isEmpty(){
        return root ==null;
    }

    public boolean contains(E x){
        return contains(x,root);
    }

    /**
     * 使用递归
     * @return
     * @throws Exception
     */
    public E findMin() throws Exception{
        if(isEmpty()){
            throw new Exception();
        }
        return findMin(root).element;
    }

    public E findMax() throws Exception{
        if(isEmpty()){
            throw new Exception();
        }
        return findMax(root).element;
    }

    public void insert(E x){
        root = insert(x,root);
    }

    public void remove(E x){
        root = remove(x,root);
    }

    public void printTree(){
        if(isEmpty()){
            System.out.println("Empty tree");
        }else{
            printTree(root);
        }
    }

    public void printTree(BinaryNode<E> t){
        if(t!=null){
            printTree(t.left);
            System.out.println(t.element);
            printTree(t.right);
        }
    }

    /**
     * 
     * @param x
     * @param t
     * @return
     */
    private boolean contains(E x,BinaryNode<E> t){
        if(t == null){
            return false;
        }

        int compareResult = x.compareTo(t.element);

        if(compareResult<0){
            return contains(x,t.left);
        }else if(compareResult>0){
            return contains(x,t.right);
        }else{
            return true;
        }
    }

    /**
     * 
     * @param t
     * @return
     */
    private  BinaryNode<E> findMin(BinaryNode<E> t){
        if(t == null){
            return null;
        }else if(t.left==null){
            return t;
        }

        return findMin(t.left);
    }

    /**
     * 
     * @param t
     * @return t
     */

    private BinaryNode<E> findMax(BinaryNode<E> t){
        if(t!=null){
            while(t.right!=null){
                t = t.right;
            }
        }
        return t;
    }

    /**
     * 
     * @param x
     * @param t
     * @return t
     */
    private BinaryNode<E> insert(E x,BinaryNode<E> t){
        if(t == null){
            return new BinaryNode<E>(x,null,null);
        }

        int compareResult =x.compareTo(t.element);
        if(compareResult<0){
            t.left = insert(x,t.left);
        }else if(compareResult>0){
            t.right = insert(x,t.right);
        }else
            ;

        return t;
    }

    private BinaryNode<E> remove(E x,BinaryNode<E> t){
        if(t==null){
            return t;
        }

        int compareResult = x.compareTo(t.element);
        if(compareResult<0){
            t.left = remove(x, t.left);
        }else if(compareResult>0){
            t.right = remove(x,t.right);
        }else if(t.left !=null&&t.right!=null){
            t.element = findMin(t.right).element;
            t.right = remove(t.element,t.right);
        }else{
            t = (t.left!=null)?t.left:t.right;

        }

        return t;
    }
}

测试代码：

package com.tree.demo;

public class BinarySearchTreeTest {

    public static void main(String[] args) throws Exception {
        BinarySearchTree<Integer> tree = new BinarySearchTree<Integer>();
        tree.insert(5);
        tree.insert(1);
        tree.insert(3);
        tree.insert(7);
        tree.insert(10);
        tree.insert(4);
        System.out.println("原始数据:");
        tree.printTree();

        System.out.println("是否包含:"+tree.contains(3));
        System.out.println("最大值:"+tree.findMax());
        System.out.println("最小值:"+tree.findMin());
        tree.remove(3);
        System.out.println("删除之后的数据:");
        tree.printTree();
    }

}

结果显示:
原始数据:
1
3
4
5
7
10
是否包含true
最大值10
最小值1
删除之后的数据:
1
4
5
7
10
就这样，一个基本的查找二叉树完成了，欢迎大家讨论！