【Java】二叉排序树

线性结构
顺序存储，不排序:查找困难
顺序存储，排序:删除插入困难
链式存储:无论是否排序，查找困难

二叉排序树,也叫二叉查找树，二叉搜索树: BST；
对于二叉树中的任何一个非叶子节点，要求左子节点比当前节点值小，右子节点比当前节点值大。
创建二叉排序树以后，按照中序遍历正好是从小到大排序

创建树

public class BinarySortTree {
    Node root;

    /**
     * 向二叉排序树中添加节点
     * @param node 节点
     */
    public void add(Node node){
        //如果是空树
        if(root==null)
        {
            root=node;
        }else root.add(node);
    }
    //中序遍历(正好是从小到大排序)
    public void midShow()
    {
        if(root!=null)
        {
            //root.midShow(root);
            root.midShow();
        }
    }

    //查找节点
    public Node search(int value)
    {
        if(root==null) return null;
        else { return root.search(value);}
    }

    //删除节点
    public void delete(int value)
    {
        if(root==null)return;
        else {
            //找到这个节点
            Node target=search(value);
            //如果没有
            if(target==null)
            {
                return;
            }
            //找到他的父节点
            Node parent = searchParent(value);
            //要删除的节点是叶子节点
            if(target.leftNode==null&&target.rightNode==null)
            {
                //要删除的节点是父节点的左节点
                if(parent.leftNode.value==value)
                {
                    parent.leftNode=null;
                }
                //要删除的节点是父节点的右节点
                else {
                    parent.rightNode=null;
                }
            }
            //要删除的节点有两个子节点
            else if(target.leftNode!=null&&target.rightNode!=null)
            {

            }
            //要删除的节点只有一个子节点
            else {
                //有左子节点
                if(target.leftNode!=null)
                {
                    if(parent.leftNode.value==value) {
                        parent.leftNode = target.leftNode;
                    }else {
                        parent.rightNode=target.leftNode;
                    }
                }
                //有右子节点
                else {
                    if(parent.leftNode.value==value) {
                        parent.leftNode = target.rightNode;
                    }else {
                        parent.rightNode=target.rightNode;
                    }
                }
            }
        }
    }

    /**
     * 搜索父节点
     * @param value
     * @return
     */
    public Node searchParent(int value)
    {
        if(root==null)return null;
        else {
           return root.searchParent(value);
        }
    }
}

创建树节点

public class Node {
    int value;
    Node leftNode;
    Node rightNode;

    public Node(int value)
    {
        this.value=value;
    }

    //添加节点
    public void add(Node node)
    {
        if(node==null)return;
        //判断传入节点的值与当前子树根节点的值大小
        if(node.value<this.value)
        {
            //如果左节点为空
            if(this.leftNode==null)this.leftNode=node;
            else this.leftNode.add(node);
        }else {
            //如果右节点为空
            if(this.rightNode==null)this.rightNode=node;
            else this.rightNode.add(node);
        }
    }

    //中序遍历
    public void midShow1(Node node){
        if(node==null)return;
        midShow1(node.leftNode);
        System.out.println(node.value);
        midShow1(node.rightNode);
    }
    public void midShow(){
        if(leftNode!=null)
        {
            leftNode.midShow();
        }
        System.out.println(value);
        if(rightNode!=null)
        {
            rightNode.midShow();
        }
    }

    /**
     * 查找节点
     * @param value
     * @return
     */
    public Node search(int value)
    {
        if(value==this.value)
        {
            return this;
        }else if(value<this.value)
        {
            if(leftNode==null)return null;
            else return leftNode.search(value);
        }
        else
        {
            if(rightNode==null)return null;
            else return rightNode.search(value);
        }
    }

    /**
     * 删除节点
     * @param value
     */
    public void delete(int value)
    {
        if(this.value==value){

        }
    }

    /**
     * 搜索父节点
     * @param value
     * @return
     */
    public Node searchParent(int value) {
        if((this.leftNode!=null&&this.leftNode.value==value)
        ||(this.rightNode!=null&&this.rightNode.value==value))
        {
            return this;
        }else {
            if(this.value>value&&this.leftNode!=null)
            {
                return this.leftNode.searchParent(value);
            }else if(this.value<value&&this.rightNode!=null)
            {
                return this.rightNode.searchParent(value);
            }
        }
        return null;
    }
}

测试

public class Main {

    public static void main(String[] args) {
	// write your code here
        int[] array=new int[]{7,3,10,12,5,1,9};
        BinarySortTree binarySortTree=new BinarySortTree();
        for (int i=0;i<array.length;i++)
        {
            binarySortTree.add(new Node(array[i]));
        }
        binarySortTree.midShow();
        System.out.println("-------------");
        Node node=binarySortTree.search(10);
        Node node1=binarySortTree.search(20);
        System.out.println(node.value);
        System.out.println(node1);
        System.out.println("-------------");
        //查找父节点
        Node node2=binarySortTree.searchParent(5);
        System.out.println(node2.value);
        System.out.println("-------------");
        //删除叶子节点
        binarySortTree.delete(5);
        binarySortTree.midShow();
        //删除叶子节点
        System.out.println("-------------");
        binarySortTree.delete(3);
        binarySortTree.midShow();
    }
}