二叉排序树的中序遍历为什么遍历不出来呢？

package Find;

public class Find {
public static void main(String args[]) {
BSTree bstree = new BSTree();
int[] k= {109,72,33,70,43,64,110,59};
String[] item = {"m","H","!","F","+","@","n",";"} ;
KeyType[] key = new KeyType[k.length];
ElementType[] elem = new ElementType[k.length];
System.out.println("原序列：");
for (int i= 0;i<k.length;i++) {
key[i] = new KeyType(k[i]);
elem[i] = new ElementType(item[i]);
if(bstree.insertBST(key[i],elem[i])) {
System.out.print("["+key[i]+","+elem[i]+"]");
}
}
System.out.println("\n中序遍历二叉排序树：");
bstree.inOrderTraverse(bstree.root);
System.out.println();
KeyType keyvalue = new KeyType();
keyvalue.key = 43;
RecordNode found = (RecordNode)bstree.searchBST(keyvalue);
if(found!=null) {
System.out.println("查找关键码："+keyvalue+"，成功！对应符号为："+found.element);
}else {
System.out.println("查找关键码："+keyvalue+"，失败！");
}
keyvalue.key = 39;
found = (RecordNode)bstree.searchBST(keyvalue);
if(found!= null) {
System.out.println("查找关键码："+keyvalue+"，成功！对应符号为："+found.element);
}else {
System.out.println("查找关键码："+keyvalue+"，失败！");
}
keyvalue.key =64;
found = (RecordNode)bstree.removeBST(keyvalue);
if(found!=null) {
System.out.println("删除关键码："+keyvalue+"，成功！对应符号为："+found.element);
}else {
System.out.println("删除关键码："+keyvalue+"，失败！");
}
System.out.println("\n删除关键码："+keyvalue+"后的中序遍历序列：");
bstree.inOrderTraverse(bstree.root);
System.out.println("");

}}

public class BSTree {
public BiTreeNode root;
public BSTree(){
root = null;
}

    public void inOrderTraverse(BiTreeNode biTreeNode){
        if (biTreeNode != null){
            inOrderTraverse(biTreeNode.lchild);
            System.out.print(((RecordNode)biTreeNode.data).toString() + " ");
            inOrderTraverse(biTreeNode.rchild);
        }
    }

    
    public Object searchBST( Comparable key){
        if (key == null || ! (key instanceof Comparable)){
            return null;
        }
        return searchBST(root,key);
    }

    private Object searchBST(BiTreeNode biTreeNode, Comparable key) {
        if (biTreeNode != null){
            if (key.compareTo(((RecordNode) biTreeNode.data).key ) == 0){
                return biTreeNode.data;
            }
            if (key.compareTo(((RecordNode) biTreeNode.data).key) < 0){
                return searchBST(biTreeNode.lchild,key);       
            }else {
                return searchBST(biTreeNode.rchild,key);      
            }
        }
        return null;
    }


    public boolean insertBST(Comparable new_key , Object new_element){
        if (new_key == null || !(new_key instanceof Comparable))    
            return false;
        if (root == null){
            root = new BiTreeNode(new RecordNode((KeyType) new_key,new_element));
            return true;
        }
        return insertBST(root,new_key,new_element);
    }
    private boolean insertBST(BiTreeNode biTreeNode,Comparable key,Object element){
        if (key.compareTo(((RecordNode)biTreeNode.data).key) == 0)
            return false;
        if (key.compareTo(((RecordNode)biTreeNode.data).key) < 0){
            if (biTreeNode.lchild == null){
                biTreeNode.lchild = new BiTreeNode(new RecordNode((KeyType) key,element));
                return true;
            }else {
                return insertBST(biTreeNode.lchild,key,element);
            }
        }else if (biTreeNode.rchild == null){
            biTreeNode.rchild = new BiTreeNode(new RecordNode((KeyType) key,element));
            return true;
        }else {
            return insertBST(biTreeNode.rchild,key,element);
        }
    }

    public Object removeBST(Comparable key){
        if (root == null || key == null || !(key instanceof Comparable)){
            return null;
        }
        return removeBST(root,key,null);}
         private Object removeBST(BiTreeNode biTreeNode,Comparable elemKey,BiTreeNode parent){
                    if (biTreeNode != null){
                        if (elemKey.compareTo(((RecordNode) biTreeNode.data).key) < 0) {
                            return removeBST(biTreeNode.lchild, elemKey, biTreeNode);
                        }else if (elemKey.compareTo(((RecordNode) biTreeNode.data).key) > 0){
                            return removeBST(biTreeNode.rchild,elemKey,biTreeNode);
                        }else if (biTreeNode.lchild != null && biTreeNode.rchild != null) {  
                            BiTreeNode innext = biTreeNode.rchild;
                            while(innext.lchild != null){  
                                innext = innext.rchild;
                            }
                            biTreeNode.data = innext.data;  
                            return removeBST(biTreeNode.rchild,((RecordNode) biTreeNode.data).key,biTreeNode);  
                        }else{
                            
                            if (parent == null){
                                if (biTreeNode.lchild != null){
                                    root = biTreeNode.lchild;
                                }else {
                                    root = biTreeNode.rchild;
                                }
                                return biTreeNode.data;
                            }
                            if (biTreeNode == parent.lchild){
                                if (biTreeNode.lchild != null){
                                    parent.lchild = biTreeNode.lchild;
                                }else{
                                    parent.lchild = biTreeNode.rchild;
                                }
                            }else if (biTreeNode.lchild != null){
                                parent.rchild = biTreeNode.lchild;
                            }else{
                                parent.rchild = biTreeNode.rchild;
                            }
                            return biTreeNode.data;     
                        }
                    }
                    return null;
                }            
        }

得到的结果
原序列：
[109,m][72,H][33,!][70,F][43,+][64,@][110,n][59,;]
中序遍历二叉排序树：
Find.RecordNode@7a79be86 Find.RecordNode@34ce8af7 Find.RecordNode@b684286 Find.RecordNode@880ec60 Find.RecordNode@3f3afe78 Find.RecordNode@7f63425a Find.RecordNode@36d64342 Find.RecordNode@39ba5a14
查找关键码：43，成功！对应符号为：+
查找关键码：39，失败！
删除关键码：64，成功！对应符号为：@

删除关键码：64后的中序遍历序列：
Find.RecordNode@7a79be86 Find.RecordNode@34ce8af7 Find.RecordNode@b684286 Find.RecordNode@3f3afe78 Find.RecordNode@7f63425a Find.RecordNode@36d64342 Find.RecordNode@39ba5a14