二叉排序树

Posted 2020-12-18 huangshen

二叉排序树

二叉排序树：BST: (Binary Sort(Search) Tree), 对于二叉排序树的任何一个非叶子节点，要求左子节点的值比当前节点的值小，右子节点的值比当前节点的值大。

二叉排序树创建和遍历

? 一个数组创建成对应的二叉排序树，并使用中序遍历二叉排序树 使用中序遍历的二叉树结点数值由小到大排序

/**
     * 二叉排序树的创建
     * @param value 结点的值
     * @return 创建的根节点
     */
    public static BinarySortNode createTree(int value) {
        return new BinarySortNode(value);

    }

    /**
     * 向二叉排序树中添加数值
     * @param root 二叉排序树的根节点
     * @param value 要添加的数值
     */
    public static void add(BinarySortNode root, int value) {
        if (root == null) return;
        if (root.getValue() > value) {
            if (root.getLeft() == null) {
                root.setLeft(new BinarySortNode(value));
            } else {
                add(root.getLeft(), value);
            }
        } else {
            if (root.getRight() == null) {
                root.setRight(new BinarySortNode(value));
            } else {
                add(root.getRight(), value);
            }
        }

    }


    public static  void  inOrderTraversal(BinarySortNode node){
        if (node==null)return;
        inOrderTraversal(node.getLeft());
        System.out.println(node.getValue());
        inOrderTraversal(node.getRight());
    }

二叉排序树的删除

二叉排序树的删除情况比较复杂，有下面三种情况需要考虑

删除叶子节点

删除只有一颗子树的节点

删除有两颗子树的节点.

/**
     * 二叉排序树查找
     *
     * @param value 要查找的值
     * @return 找到后返回找到结点 找不到返回null
     */
    public static BinarySortNode search(BinarySortNode node, int value) {
        if (node == null) return null;
        else if (node.getValue() == value) return node;
        else if (node.getValue() > value) {
            return search(node.getLeft(), value);
        } else if (node.getValue() < value) {
            return search(node.getRight(), value);
        } else {
            return null;
        }

    }

    /**
     * 查找要删除结点的父亲结点
     *
     * @param node
     * @param value
     * @return
     */
    public static BinarySortNode searchFather(BinarySortNode node, int value) {
        if (node == null) return null;
        else if ((node.getLeft() != null && node.getLeft().getValue() == value) || (node.getRight() != null && node.getRight().getValue() == value))
            return node;
        else if (node.getValue() > value) {
            return searchFather(node.getLeft(), value);
        } else if (node.getValue() < value) {
            return searchFather(node.getRight(), value);
        } else {
            return null;
        }
    }


    public static BinarySortNode searchMinNode(BinarySortNode node) {

        if (node.getLeft() == null) return node;
        else return searchMinNode(node.getLeft());

    }

    /**
     * @param value 要删除结点的值
     * @return 删除是否成功 成功返回true 失败返回false
     */
    public static boolean delete(BinarySortNode root, int value) {
        BinarySortNode father = searchFather(root, value);
        BinarySortNode node = search(root, value);
        if (node.getRight() == null && node.getLeft() == null) {
            //要删除的结点是叶子结点 即左右孩子均为空

            if (father.getLeft() == node) {
                //要删除的结点在父节点的左结点上
                father.setLeft(null);
                return true;
            } else if (father.getRight() == node) {
                //要删除的结点在父节点的右节点上
                father.setRight(null);
                return true;
            } else {
                return false;
            }

        } else if (node.getRight() == null && node.getLeft() != null) {
            //要删除的结点只有一个孩子结点 只有左孩子

            if (father.getLeft() == node) {
                //要删除的结点在父节点的左结点上
                father.setLeft(node.getLeft());
                return true;
            } else if (father.getRight() == node) {
                //要删除的结点在父节点的右节点上
                father.setRight(node.getLeft());
                return true;
            } else {
                return false;
            }

        } else if (node.getRight() != null && node.getLeft() == null) {
            //要删除的结点只有一个结点 只有右孩子

            if (father.getLeft() == node) {
                //要删除的结点在父节点的左结点上
                father.setLeft(node.getRight());
                return true;
            } else if (father.getRight() == node) {
                //要删除的结点在父节点的右节点上
                father.setRight(node.getRight());
                return true;
            } else {
                return false;
            }

        } else {
            //要删除的结点左右孩子均不为空

            BinarySortNode minNode = searchMinNode(node.getRight());
            if (father == null) {
                //要删除的是根节点
                BinarySortNode minFather = searchFather(root, minNode.getValue());
                if (minFather==root){
                    minFather.setValue(minNode.getValue());
                    minFather.setRight(minNode.getRight());

                    return true;
                }else {
                    root.setValue(minNode.getValue());
                    minFather.setLeft(minNode.getRight());
                }

//                minFather.setLeft(minNode.getRight());
//               node.setValue(minNode.getValue());


                return false;
            } else if (father.getLeft() == node) {
                //要删除的结点在父节点的左结点上
                if (node.getRight() == minNode) {
                    father.setLeft(minNode);
                } else {
                    BinarySortNode minFather = searchFather(father, minNode.getValue());
                    minFather.setLeft(minNode.getRight());
                    node.setValue(minNode.getValue());
                    minNode=null;
                }

                return true;
            } else if (father.getRight() == node) {
                //要删除的结点在父节点的右节点上
                if (node.getRight() == minNode) {
                    father.setRight(minNode);
                } else {
                    BinarySortNode minFather = searchFather(father, minNode.getValue());
                    minFather.setLeft(minNode.getRight());
                    node.setValue(minNode.getValue());
                    minNode=null;
                }
                return true;
            } else {

                return false;
            }

        }


    }