二叉排序树

二叉排序树

概念：左孩子节点值 < 父节点值 < 右孩子节点值

查找

先查找根节点，如果查找值比根节点小，继续查左子树，比根节点大，继续查找右子树

   public static Integer search(int value) {
        TreeNode node = root;
        while (node != null) {
            if (node.value > value) {
                node = node.leftChild;
            } else if (node.value < value) {
                node = node.rightChild;
            } else {
                return node.value;
            }
        }
        return null;
    }

新增

插入节点大于当前节点

• 如果当前节点没有右子节点，则插入到当前节点右子节点的位置
• 否则当前节点指向当前节点的右子节点

插入节点小于当前节点

• 如果当前节点没有左子结点，则插入节点插入到当前节点左子结点的位置
• 否则当前节点指向当前节点的左子结点

    /**
     * 插入
     * @param value
     */
    public static void insertNode(int value) {
        TreeNode node = root;
        TreeNode insertNode = new TreeNode(value);
        while (node != null) {
            if (node.value > value) {
                if (node.leftChild == null) {
                    node.leftChild = insertNode;
                    return;
                }
                node = node.leftChild;
            } else {
                if (node.rightChild == null) {
                    node.rightChild = insertNode;
                    return;
                }
                node = node.rightChild;
            }
        }
    }

删除

分三种情况

• 删除节点是叶子节点，直接删就行了
• 删除节点只有一个子节点，子节点顶上
• 删除节点有两个节点，找到待删除节点的右子树的最小节点顶上，并删除该节点

    /**
     * 删除
     */
    public static void deleteNode(int value) {
        // node 指向要删除的节点，初始化指向根节点
        TreeNode node = root;
        TreeNode nodeParent = null; // pp 记录的是 p 的父节点
        while (node != null && node.value != value) {
            nodeParent = node;
            if (value > node.value) {
                node = node.rightChild;
            } else {
                node = node.leftChild;
            }
        }
        if (node == null) return; // 没有找到

        // 要删除的节点有两个子节点
        if (node.leftChild != null && node.rightChild != null) { // 查找右子树中最小节点
            TreeNode minP = node.rightChild;
            TreeNode minPP = node; // minPP 表示 minP 的父节点
            while (minP.leftChild != null) {
                minPP = minP;
                minP = minP.leftChild;
            }
            node.value = minP.value; // 将 minP 的数据替换到 p 中
            node = minP; // 下面就变成了删除 minP 了
            nodeParent = minPP;
        }

        // 删除节点是叶子节点或者仅有一个子节点
        TreeNode child; // p 的子节点
        if (node.leftChild != null) child = node.leftChild;
        else if (node.rightChild != null) child = node.rightChild;
        else child = null;

        // 要删除的节点置为null
        if (nodeParent == null) node = child; // 删除的节点有子节点
        else if (nodeParent.leftChild == node) nodeParent.leftChild = child;
        else nodeParent.rightChild = child;
    }

最大节点

右子树的最右节点

 /**
     * 最大节点
     */
    public static Integer findMax() {
        TreeNode node = root;
        while (node != null) {
            if (node.rightChild != null) {
                node = node.rightChild;
            } else {
                return node.value;
            }
        }
        return null;
    }

最小节点

左子树的最左节点

    /**
     * 最小节点
     */
    public static Integer findMin() {
        TreeNode node = root;
        while (node != null) {
            if (node.leftChild != null) {
                node = node.leftChild;
            } else {
                return node.value;
            }
        }
        return null;
    }