二叉搜索树的插入和删除的Java实现

二叉搜索树符合以下性质:

(1)左子树结点都小于根节点

(2)右子树结点都大于根节点

(3)左右子树都是二叉搜索树

二叉搜索树的Java实现,不能像C++一样用递归实现,因为Java的参数传递只有值传递,所以实现起来不像C++这么好理解

 

首先是插入:1.当根节点为空时,让根节点new一下

                  2.根节点不空,开始找第一个空的位置,比根结点小往左移动,比根节点大往右移动

                  3.已经有相同元素返回false

 

然后是删除:1.删除根节点分三种情况:左右子树都不空,左子树不空,其他

                      (1)根结点左右子树都不空,则用临时变量记住右子树中序序列第一位的data,然后递归删除data,再把data赋给根结点                            数据

                       (2)右子树不空:root=root.right

                       (3)其他:root=root.left

                    2.删除非根结点也是和根结点一样三种情况,不一样的地方需要记住被删除结点del的父结点current

                       (1)del结点左右子树都不空,则用临时变量记住右子树中序序列第一位的data,然后递归删除data,再把data赋给del结                              点数据

                      (2)右子树不空:根据del结点在current结点的方向将del.right赋给current结点需要删除的方向

                      (3)其他:根据del结点在current结点的方向将del.leftt赋给current结点需要删除的方向

附上代码:结点

public class BinTreeNode<T> {//二叉树结点
    public T data;
    BinTreeNode<T> leftChild,rightChild;

    public BinTreeNode(){
        leftChild=null;
        rightChild=null;
    }

    public BinTreeNode(T x){
        data=x;
        leftChild=null;
        rightChild=null;
    }
}

二叉搜索树:

public class BST<T extends Comparable>{//二叉搜索树
    protected BinTreeNode<T> root;

    public BST(){
        root=null;
    }


    public boolean Search(final T x){
        return (Search(x,root)!=null)?true:false;
    }

    private BinTreeNode<T> Search(final T x,BinTreeNode<T> ptr){
        if (ptr==null)
            return null;
        else if (x.compareTo(ptr.data)<0)
            return Search(x,ptr.leftChild);
        else if (x.compareTo(ptr.data)>0)
            return Search(x,ptr.rightChild);
        else
            return ptr;
    }

    public boolean Insert(final T item){
        if (root==null){
            root=new BinTreeNode<T>(item);
            return true;
        }
        BinTreeNode<T> ptr=root;
        while (ptr!=null){
            if (ptr.data.equals(item))
                return false;
            else if (item.compareTo(ptr.data)<0) {
                if (ptr.leftChild==null){
                    ptr.leftChild=new BinTreeNode<T>(item);
                    break;
                }
                ptr=ptr.leftChild;
            }
            else{
                if (ptr.rightChild==null){
                    ptr.rightChild=new BinTreeNode<T>(item);
                    break;
                }
                ptr=ptr.rightChild;
            }
        }
        return true;
    }

    public boolean Remove(final T item){
        BinTreeNode<T> temp;
        T value;
        if (root.data.equals(item))
        {
            if (root.rightChild!=null && root.rightChild!=null){
                temp=root.rightChild;
                while (temp.leftChild!=null)
                    temp=temp.leftChild;
                value=temp.data;
                Remove(value);
                root.data=value;
            }
            else if (root.rightChild!=null)
                root=root.rightChild;
            else
                root=root.leftChild;
            return true;
        }
        BinTreeNode<T> del=root,current=null;
        while (del!=null){
            if (del.data.equals(item)){
                if (del.leftChild!=null && del.rightChild!=null){
                    temp=del.rightChild;
                    while (temp.leftChild!=null)
                        temp=temp.leftChild;
                    value=temp.data;
                    Remove(value);
                    del.data=value;
                }
                else if (del.rightChild!=null){
                    if (current.leftChild==del)
                        current.leftChild=del.rightChild;
                    else
                        current.rightChild=del.rightChild;
                }
                else {
                    if (current.leftChild==del)
                        current.leftChild=del.leftChild;
                    else
                        current.rightChild=del.leftChild;
                }
                return true;
            }
            else if (item.compareTo(del.data)<0) {
                current=del;
                del=del.leftChild;
            }
            else{
                current=del;
                del=del.rightChild;
            }
        }
        return false;
    }

    public void output()
    {
        PrintBTree(root);
        System.out.println();
    }
    private void PrintBTree(BinTreeNode<T> subTree){
        if (subTree!=null){
            System.out.print(subTree.data);
            if (subTree.leftChild!=null||subTree.rightChild!=null){
                System.out.print('(');
                PrintBTree(subTree.leftChild);
                System.out.print(',');
                PrintBTree(subTree.rightChild);
                System.out.print(')');
            }
        }
    }
}

另有搜索和广义表形式输出,可以用于测试