数据结构之： 二叉排序树

二叉排序树概述

二叉排序树的规则比较简单：二叉排序树又名二叉搜索树（BST）,对于二叉树中任何一个叶子节点，要求其左子节点小于当前节点，右子节点大于当前节点。根据名字我们可以知道这种二叉树结构它的查找效率是比较高的

如图所示：

它的中序遍历为：1 3 5 7 10 19 23
其实二叉排序树的中序遍历就是一个有序的数组

二叉排序树代码实现

package tree;

/**
 * 二叉排序树
 */
public class SortBinaryNode {
    private int value;
    private SortBinaryNode leftNode;
    private SortBinaryNode rightNode;

    public void setValue(int value) {
        this.value = value;
    }

    public int getValue() {
        return value;
    }

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

    public SortBinaryNode getLeftNode() {
        return leftNode;
    }

    public void setLeftNode(SortBinaryNode leftNode) {
        this.leftNode = leftNode;
    }

    public SortBinaryNode getRightNode() {
        return rightNode;
    }

    public void setRightNode(SortBinaryNode rightNode) {
        this.rightNode = rightNode;
    }
    /**
     * 中序遍历二叉排序树
     */
    public void middleShow(SortBinaryNode node) {
        if (node == null) {
            return;
        }
        middleShow(node.getLeftNode());
        System.out.println(node.getValue());
        middleShow(node.getRightNode());
    }

    /**
     * @param value
     * @return
     */
    public SortBinaryNode search(int value) {
        if (this.getValue() == value){
            return this;
        }
        if (this.getValue()>value){
            return this.getLeftNode().search(value);
        }
        if (this.getValue()<value){
            return this.getRightNode().search(value);
        }

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

package tree;

public class BinarySortTree {
    private SortBinaryNode root;

    /**
     * 添加二叉排序树
     *
     * @param node
     */
    public void add(SortBinaryNode node) {
        if (node == null) {
            return;
        }
        //判断当前节点的大小
        if (node.getValue() < root.getValue()) {
            if (root.getLeftNode() == null) {
                root.setLeftNode(node);
            } else {
                add(node);
            }
        } else {
            if (root.getRightNode() == null) {
                root.setRightNode(node);
            } else {
                this.add(node);
            }
        }
    }

    /**
     * 删除节点
     *
     * @param value
     */
    public void delete(int value) {
        if (root == null) {
            return;
        }
        SortBinaryNode target = root.search(value);
        SortBinaryNode parent = root.searchParent(value);
        //删除节点
        if (target.getLeftNode()==null&&target.getRightNode()==null){
            if (parent.getRightNode().getValue() == value){
                parent.setRightNode(null);
            }
            if (parent.getLeftNode().getValue()==value){
                parent.setLeftNode(null);
            }
        }
        //  删除有两个子节点的情况
        else if(target.getLeftNode()!=null&& target.getRightNode()!=null){
            int min = deleteMin(target.getRightNode());
            target.setValue(min);

        }
        //删除只有一个节点的情况
        else {
            if (target.getLeftNode()!=null){
                if (parent.getLeftNode().getValue()== value){
                    parent.setLeftNode(target.getLeftNode());
                }else {
                    parent.setRightNode(target.getLeftNode());
                }
            }
            else {
                if (parent.getRightNode().getValue()==value){
                    parent.setLeftNode(target.getRightNode());
                }else {
                    parent.setRightNode(target.getRightNode());
                }
            }
        }
    }

    private int deleteMin(SortBinaryNode node) {
        SortBinaryNode target = node;
        while (node.getLeftNode()!=null){
            target = node.getLeftNode();
        }
        delete(target.getValue());
        return target.getValue();
    }


}