二叉排序树,又称为二叉查找树。它或者是一棵空树。或者具有以下性质

(1)若它的左子树不空,则左子树所有的结点的值均小于它的根结构的值。

(2)若它在右子树不空,则右子树上所有结点的值均大于它的根结点的值。

(3)它的左右子树也均为二叉排序树。

本人采用java语言实现了二叉排序树的基本操作。

算法实现的难点:

(1)必须在BST类定义两个全局变量

private BitNode root;//定义二叉树的根节点的全局变量

private BitNode p;//定义一个全局变量,方便查找替换变量,因为JAVA语言没有指针操作。

(2)二叉树删除结点的操作比较麻烦,因为删除后仍然保证是二叉树,分为三种情况

<1>为叶子结点删除

<2>仅有左或右子树的结点

<3>左右子树都有的结点。

心得体会:因为java语言没有C语言的简洁优雅,所以为了实现递归参数的传递,一般情况下在类里面都是操作this 指针,或者传递root根结点,root结点 是树的操作的起始部分,非常重要。

在传递参数过程中,时刻观察是否初始化,是否多次实例化等等。

比如

public boolean DeleteBST(BitNode root,int key)
    {
        if(root==null)
            return false;
        else
        {
            if(key==root.data)
                return Delete(root);
            else if(key<root.data)
                return DeleteBST(root.lchild,key);
            else
                return DeleteBST(root.rchild,key);
        }
    }
                        
    public boolean DeleteKey(int key)
    {
        //调用根结点的引用对象
        if(DeleteBST( root, key))
            return true;
        else
            return false;
    }

这样既实现了函数的调用,又不破坏程序的封装性。下面为全部实现技术

package Search;
//二叉排序树的相关操作
class BST
{
    private BitNode root;//定义二叉树的根节点的全局变量
    private BitNode p;//定义一个全局变量
    private int N;//树的结点个数
    class BitNode
    {
        int data;//定义结点数据
        BitNode lchild,rchild;//左右孩子指针
    }
    //f指向树的双亲,P为全局查找变量,防止在传递过程恢复原值
    public boolean SearchBST(BitNode root,int key,BitNode f)
    {
        if(root==null)
        {
            p=f;
            return false;
        }
        else if(key==root.data)
        {
            p=root;
            return true;
        }
        //左右递归查找
        else if(key<root.data)
            return SearchBST(root.lchild, key,root);
        else
            return SearchBST(root.rchild, key,root);
    }
      
    //二叉排序树的插入操作
      
    public boolean InsertBST(int key)
    {
        BitNode s;
        p=null;
        if(!SearchBST(root,key,null))
        {
            s=new BitNode();
            s.data=key;
            s.lchild=s.rchild=null;
            if(p==null)
            {
                root=s;//插入S为新结点,尾部插入法
            }
            else if(key<p.data)
            {
                p.lchild=s;//小于的为左孩子
            }
            else
            {
                p.rchild=s;//大于的为右孩子
            }
            N++;
            return true;
        }
        else
            return false;
    }
    //插入一个数组的结点
    public void creatbst(int arr[])
    {
        for(int i=0;i<arr.length;i++)
        {
            InsertBST(arr[i]);
        }
        p=null;//将全局变量消除掉
    }
      
    //从二叉排序树中删除结点p,并重接它的左或右子树
    public boolean Delete(BitNode p)
    {
        BitNode q,s;
        if(p.rchild==null)//右子树为空,只需要重接它的左子树
        {
            q=p;
            p=p.lchild;
            q=null;
            N--;
        }
        if(p.lchild==null)//左子树为空,只需要重接它的右子树
        {
            q=p;
            p=p.rchild;
            q=null;
            N--;
        }
        else//左右子树均不为空
        {
            q=p;
            s=p.lchild;
            while(s.rchild!=null)//转左然后向右找到尽头
            {
                q=s;
                s=s.rchild;
            }
            p.data=s.data;//用P的前驱或者后继的值来替换删除掉的位置的值
            if(q!=p)
            {
                q.rchild=s.lchild;//重接Q的右子树
            }
            else
            {
                q.lchild=s.lchild;//重接Q的左子树
            }
            s=null;
        }
        N--;
        return true;
    }
    //若二叉排序树中存在key结点,则删除该结点
    public boolean DeleteBST(BitNode root,int key)
    {
        if(root==null)
            return false;
        else
        {
            if(key==root.data)
                return Delete(root);
            else if(key<root.data)
                return DeleteBST(root.lchild,key);
            else
                return DeleteBST(root.rchild,key);
        }
    }
      
    public boolean DeleteKey(int key)
    {
        //调用根结点的引用对象
        if(DeleteBST( root, key))
            return true;
        else
            return false;
    }
    public int size()
    {
        return N;
    }
}
public class Binarysort {
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        BST bst=new BST();
        int arr[]={62,88,58,47,35,73,51,99,29,37,48,56,93,36,49,50};
        bst.creatbst(arr);
        System.out.println(bst.size());
        bst.DeleteKey(47);
        System.out.println(bst.size());
    }
}