二叉查找树（Binary Search Tree）java

 BSTNode(二叉树的节点类)

package com.java.tree.bst;

public class BSTNode {
    private int data;
    private BSTNode leftChild;
    private BSTNode rightChild;
    private int count;


    public int getData() {
        return data;
    }

    public BSTNode getLeftChild() {
        return leftChild;
    }

    public BSTNode getRightChild() {
        return rightChild;
    }

    public void setData(int data) {
        this.data = data;
    }

    public void setLeftChild(BSTNode leftChild) {
        this.leftChild = leftChild;
    }

    public void setRightChild(BSTNode rightChild) {
        this.rightChild = rightChild;
    }

    public int getCount() {
        return count;
    }

    public void setCount(int count) {
        this.count = count;
    }

    public BSTNode(){
        this.count = 1;
    }public BSTNode(int data){
        this.count = 1;
        this.data = data;
    }
}

二叉树的操作类

package com.java.tree.bst;

public class BstOperation {

    private BstOperation(){}


    public static BSTNode InitBst(int[] dataList){
        if(dataList.length==0||dataList==null)return null;
        BSTNode bstTree = new BSTNode();
        bstTree.setData(dataList[0]);
        for (int i = 1; i <dataList.length ; i++) {
            //if(!InsertBST(bstTree,dataList[i]))return null;
            InsertBST(bstTree,dataList[i]);
        }
        return bstTree;
    }

    public static BSTNode SearchBST(BSTNode bstNode,int data){
        //递归实现
        if(bstNode==null)return null;
        if(bstNode.getData()==data)return bstNode;
        if (bstNode.getData()>data)return SearchBST(bstNode.getLeftChild(),data);
        else return SearchBST(bstNode.getRightChild(),data);

        //非递归实现
       /* while(bstNode!=null){
            if (bstNode.getData()==data)return bstNode;
            else if(bstNode.getData()>data)bstNode = bstNode.getLeftChild();
            else bstNode = bstNode.getRightChild();
        }
        return null;*/
    }

    public static BSTNode InsertBST(BSTNode bstNode,int data){
        /*
        //递归实现，但是由于java是值传递,所以不能使用以下的代码
        if(bstNode==null){//空树
            bstNode = new BSTNode();
            bstNode.setData(data);
            return true;
        }
        if (bstNode.getData()>data)return InsertBST(bstNode.getLeftChild(),data);
        if (bstNode.getData()<data)return InsertBST(bstNode.getRightChild(),data);
        return false;*/
        //一下算法需要确保InsertBST(BSTNode bstNode,int data)中的bstNdoe,除了第一调用之外，其余递归过程不会使得bstNode==null
        BSTNode temp  =bstNode;
        if(bstNode==null)//空树
            return new BSTNode(data);
        if (bstNode.getData()>data){//插入到左子树中
            if(bstNode.getLeftChild()==null){
                bstNode.setLeftChild(new BSTNode(data));
            }else{//还存在右子树
                temp = InsertBST(bstNode.getLeftChild(),data);
            }
        }
        else if (bstNode.getData()<data){//插入到右子树中
            if(bstNode.getRightChild()==null){
                bstNode.setRightChild(new BSTNode(data));
            }else{//还存在右子树
                temp = InsertBST(bstNode.getRightChild(),data);
            }
        }else{
            bstNode.setCount(bstNode.getCount()+1);
        }
        return temp;

       /* BSTNode temp = bstNode;
        if (temp==null)return false;
        while(temp!=null){
            if(temp.getData()>data){
                //left
                if(temp.getLeftChild()==null){
                    temp.setLeftChild(new BSTNode());
                    temp.getLeftChild().setData(data);
                    break;
                }else {
                    temp = temp.getLeftChild();
                }

            }else if(temp.getData()<data){
                //right
                if(temp.getRightChild()==null){
                    temp.setRightChild(new BSTNode());
                    temp.getRightChild().setData(data);
                    break;
                }else {
                    temp = temp.getRightChild();
                }
            }else{
                temp.setCount(temp.getCount()+1);
                break;
            }
        }
        return true;*/
    }

    private static BSTNode deleteRoot;
    public static BSTNode DeleteBST(BSTNode bstNode,BSTNode parent,int flag,int data){
        if (flag==-1){//根节点时（即外部调用时，非递归调用时），记录下根节点
            deleteRoot = bstNode;
        }
        if (bstNode==null)return null;
        if (bstNode.getData()==data){
            if(flag==-1)  deleteRoot =  DeleteNode(bstNode,parent,flag);//要删除的节点是根节点
            DeleteNode(bstNode,parent,flag);
            return deleteRoot;
        } else if (bstNode.getData()<data)return DeleteBST(bstNode.getRightChild(),bstNode,1,data);
        else return DeleteBST(bstNode.getLeftChild(),bstNode,0,data);
    }

    private static BSTNode DeleteNode(BSTNode bstNode,BSTNode parent,int flag){
        flag:0表示bstNode是parent的左子树
        //flag:1表示bstNode是parent的右子树
        BSTNode deleteNode = bstNode;
        if (deleteNode.getRightChild()==null&&deleteNode.getLeftChild()!=null){//右子树为null,左子树不为空
            if (flag==0)parent.setLeftChild(deleteNode.getLeftChild());
            if (flag==1)parent.setRightChild(deleteNode.getLeftChild());
        }else if(deleteNode.getRightChild()!=null&&deleteNode.getLeftChild()==null){//左子树为null,右子树不为空
            if (flag==0)parent.setLeftChild(deleteNode.getLeftChild());
            if (flag==1)parent.setRightChild(deleteNode.getLeftChild());
        }else if(deleteNode.getRightChild()==null&&deleteNode.getLeftChild()==null){//都为null
            if (flag==0)parent.setLeftChild(null);
            if (flag==1)parent.setRightChild(null);
        }else{//都不为null
            //两种方法：1、  (左子树的最右节点:且最右节点的右子树为null )
            //        2、从deleteNode的右子树找最小的节点代替deleteNode (右子树的最左节点：且最左节点的左子树为null)
            //1

           /* BSTNode temp = deleteNode.getLeftChild();
            BSTNode tempParent = deleteNode;
            while(temp.getRightChild()!=null){
                tempParent = temp;
                temp = temp.getRightChild();
            }
            tempParent.setRightChild(temp.getLeftChild());

            temp.setRightChild(deleteNode.getRightChild());
            temp.setLeftChild(deleteNode.getLeftChild());

            deleteNode.setRightChild(null);
            deleteNode.setLeftChild(null);


            if (flag==0)parent.setLeftChild(temp);
            if(flag==1) parent.setRightChild(temp);

            return temp;
        }
        return null;
        */
        //2
            BSTNode temp = deleteNode.getRightChild();
            BSTNode tempParent = deleteNode;
            while(temp.getLeftChild()!=null){
                tempParent = temp;
                temp = temp.getRightChild();
            }
            tempParent.setRightChild(temp.getRightChild());

            temp.setRightChild(deleteNode.getRightChild());
            temp.setLeftChild(deleteNode.getLeftChild());

            deleteNode.setRightChild(null);
            deleteNode.setLeftChild(null);

            if (flag==0)parent.setLeftChild(temp);
            if(flag==1) parent.setRightChild(temp);

            return temp;
        }
        return null;
    }

    public static void PrintTree(BSTNode bstNode){

        if (bstNode.getLeftChild()!=null)PrintTree(bstNode.getLeftChild());
        for (int i=bstNode.getCount();i>0;i-- ){
            System.out.print(bstNode.getData()+"\t");
        }

        if (bstNode.getRightChild()!=null)PrintTree(bstNode.getRightChild());
    }


}