Java数据结构----树--二叉查找(搜索或排序)树BST

二叉查找(搜索)树（Binary Search Tree）又称二叉排序树(Binary Sort Tree),是基于二叉树，BST具有下列性质：
1、若左子树不空，则其左子树上的所有结点的值均小于根结点的值；
2、若右子树不空，则其右子树上的所有结点的值均大于根结点的值；
3、左、右子树也分别为二叉查找树。

               

结点类

public class BinaryNode {
    Integer data;
    BinaryNode leftChild;
    BinaryNode rightChild;

    public BinaryNode() {
    }

    public BinaryNode(int data) {
        leftChild = null;
        rightChild = null;
        this.data = data;
    }

    public BinaryNode(Integer data, BinaryNode leftChild, BinaryNode rightChild) {
        this.data = data;
        this.leftChild = leftChild;
        this.rightChild = rightChild;
    }
}

二叉查找树实现类

public class BinarySearchTree {
    private BinaryNode root;
    List<BinaryNode> nodeList = new LinkedList<BinaryNode>();

    //相关方法 。。。。
}

1、插入操作

    /**
     * 非递归插入操作x的过程如下：
     * 1、若b是空树，则直接将插入的结点作为根结点插入。
     * 2、x等于b的根结点的数据的值，则直接返回，否则。
     * 3、若x小于b的根结点的数据的值，则将x要插入的结点的位置改变为b的左子树，否则。
     * 4、将x要出入的结点的位置改变为b的右子树。
     */
    public boolean insert(Integer value) {
        if (root == null) {
            root = new BinaryNode(value);   //新构造一个二叉查找树
            nodeList.add(root);

        } else {
            BinaryNode parent = null;
            BinaryNode current = root;

            while (current != null) {
                //compareTo就是比较两个值，如果前者大于后者，返回1，等于返回0，小于返回-1
                if (value.compareTo(current.data) == -1) {
                    parent = current;
                    current = current.leftChild;

                } else if (value.compareTo(current.data) == 1) {
                    parent = current;
                    current = current.rightChild;
                    
                } else
                    return false;
            }

            if (value.compareTo(parent.data) == -1)
                parent.leftChild = new BinaryNode(value);
            else
                parent.rightChild = new BinaryNode(value);

            nodeList.add(parent);
        }
        return true;
    }

递归插入：

    /**
     * 递归插入: 得到的nodeList的size不是插入数据的大小！！！
     */
    public BinaryNode recursiveInsert(Integer value) {
        return recursiveInsert(value, this.root);
    }

    private BinaryNode recursiveInsert(Integer value, BinaryNode node) {
        if (root == null)
            root = new BinaryNode(value);   //新构造一个二叉查找树

        if (node == null)  //如果是叶节点，则没有孩子
            return new BinaryNode(value, null, null);

        int result = value.compareTo(node.data);

        //value小于node.data返回-1
        if (result == -1) {
            node.leftChild = recursiveInsert(value, node.leftChild);

        } else if (result == 1) {
            node.rightChild = recursiveInsert(value, node.rightChild);
        }

        nodeList.add(node);
        return node;
    }

测试：

    @Test
    public void test() {
        BinarySearchTree tree = new BinarySearchTree();
        BinarySearchTree tree1 = new BinarySearchTree();
        int[] keys = new int[] { 8, 3, 10, 1, 6, 14, 4, 7, 13 };

        for (int key:keys){
            tree.insert(key);
            tree1.recursiveInsert(key);
        }

        List<BinaryNode> list = tree.getBinarySearchTree();
        List<BinaryNode> list1 = tree1.getBinarySearchTree();

        System.out.println("非递归插入节点后，树的大小："+ list.size());
        System.out.println("递归插入节点后，树的大小：" + list1.size());
    }

非递归插入节点后，树的大小：9
递归插入节点后，树的大小：17

2、删除操作

对于二叉查找树的删除操作（这里根据值删除，而非结点）分三种情况：
不过在此之前，我们应该确保根据给定的值找到了要删除的结点，如若没找到该结点不会执行删除操作！这里暂时没有考虑
下面三种情况假设已经找到了要删除的结点。
1、如果结点为叶子结点（没有左、右子树），此时删除该结点不会玻化树的结构直接删除即可，并修改其父结点指向它的引用为null.如下图:

2、如果其结点只包含左子树，或者右子树的话，此时直接删除该结点，并将其左子树或者右子树设置为其父结点的左子树或者右子树即可，此操作不会破坏树结构。

 3、当结点的左右子树都不空的时候，一般的删除策略是用其右子树的最小数据（容易找到）代替要删除的结点数据并递归删除该结点（此时为null），因为右子树的最小结点不可能有左孩子，所以第二次删除较为容易。z的左子树和右子树均不空。找到z的后继y，因为y一定没有左子树，所以可以删除y，并让y的父亲节点成为y的右子树的父亲节点，并用y的值代替z的值.如图：

实现代码

    public void remove(Integer value) {
        this.root = remove(value,root);
    }

    /**
     * 递归删除：
     *
     * eg:添加的节点顺序为8，3，9.删除根结点，返回值则为3
     * @return 返回值始终是最新的根节点！！！
     */
    private BinaryNode remove(Integer value, BinaryNode node) {
        if (node == null)
            return null;

        int result = value.compareTo(node.data);

        //result<0：表示需要删除的节点在左子树
        if (result == -1) {
            node.leftChild = remove(value, node.leftChild);

        } else if (result == 1) {//在右子树
            node.rightChild = remove(value, node.rightChild);

        } else if (node.leftChild != null && node.rightChild != null) { //结点的左右子树都不时候
            //先找到需要删除的节点下，右子树中最小的节点并将它的值赋给需要删除的节点。
            node.data = findMin(node.rightChild).data;  //找出右子树最小值（因为右子树中的节点的值一定大于根节点）
            //删除前面找到的最小的节点
            node.rightChild = remove(node.data, node.rightChild);

        }else {
            //找到需要删除的节点且节点下有一个子节点（左或者右）
            node = (node.leftChild != null) ? node.leftChild : node.rightChild;
        }

        return node;
    }

3、查找

    /**
     * 在二叉查找树中查找x的过程如下：
     * 1、若二叉树是空树，则查找失败。
     * 2、若x等于根结点的数据，则查找成功，否则。
     * 3、若x小于根结点的数据，则递归查找其左子树，否则。
     * 4、递归查找其右子树。
     */
    public boolean find(Integer value) {
        return contains(value, this.root);
    }

    private boolean contains(Integer value, BinaryNode node) {
        if (node == null)
            return false;

        int result = value.compareTo(node.data); //-1,0,1
        if (result == -1) {
            return contains(value, node.leftChild); //递归查询左子树

        }else if (result == 1) {
            return contains(value, node.rightChild); //递归查询右子树

        } else {
            return true;
        }
    }

4、其它相关方法

    //获取二叉查找树
    public List<BinaryNode> getBinarySearchTree() {
        return nodeList;
    }

    /**
     * 找出最小的值
     * @return 返回最小值
     */
    public Integer findMin() {
        return findMin(root).data;
    }
    private BinaryNode findMin(BinaryNode node) {
        if (node == null)
            return null;
        else if (node.leftChild == null) //如果左孩子没有，只返回根结点
            return node;

        return findMin(node.leftChild);
    }

    /**
     * 找出最大的值
     */
    public Integer findMax() {
        return findMax(root).data;
    }
    private BinaryNode findMax(BinaryNode node) {
        if (node ==null)
            return null;
        else if (node.rightChild == null)
            return node;
        else
            return findMax(node.rightChild);
    }


    public void inOrderTraverse() {
        inOrderTraverse(root);
    }

    /**
     * 递归中序排序:
     * 二叉查找树中序排序后的二叉查找树是有序的
     */
    public void inOrderTraverse(BinaryNode node) {
        if (node != null) {
            inOrderTraverse(node.leftChild);
            System.out.print(node.data + " ");
            inOrderTraverse(node.rightChild);
        }
    }