根据值K将BST分为两个平衡的BST

二叉搜索树（Binary Search Tree，BST）是一种基于二分查找的数据结构，具有快速查找、插入、删除等操作的优点。本篇文章将介绍如何根据值K将BST分为两个平衡的BST。

算法思路

我们可以首先遍历一遍BST，统计出所有节点的数量n，然后根据n和值K，计算出左右两个子树应该包含的节点数量。

然后，我们可以采用递归的方式遍历BST，将节点逐个插入到左或右子树中，直到每个子树所包含的节点数量达到了预定的数量。

最后，我们可以通过对左右子树进行平衡操作，使得左右子树都平衡。具体的平衡算法可以参考平衡二叉树（AVL Tree）。

代码实现

下面是Java语言的实现代码，其中的Node类表示BST的节点，insertNode()方法表示将节点插入到左或右子树中，splitIntoTwoBalancedBST()方法表示根据值K将BST分为两个平衡的BST。

class Node {
    int val;
    Node left;
    Node right;

    Node(int val) {
        this.val = val;
    }

    void insertNode(int val) {
        if (val < this.val) {
            if (left == null) {
                left = new Node(val);
            } else {
                left.insertNode(val);
            }
        } else {
            if (right == null) {
                right = new Node(val);
            } else {
                right.insertNode(val);
            }
        }
    }
}

void splitIntoTwoBalancedBST(Node root, int K) {
    if (root == null) {
        return;
    }
    int n = countNodes(root);
    int leftSize = countNodesLessThanK(root, K);
    int rightSize = n - leftSize;
    root = insertIntoBST(root, K);
    Node[] leftAndRight = splitIntoTwo(root, leftSize, rightSize);
    Node left = balanceBST(leftAndRight[0]);
    Node right = balanceBST(leftAndRight[1]);
}

int countNodes(Node root) {
    if (root == null) {
        return 0;
    }
    return 1 + countNodes(root.left) + countNodes(root.right);
}

int countNodesLessThanK(Node root, int K) {
    if (root == null) {
        return 0;
    }
    if (root.val < K) {
        return 1 + countNodesLessThanK(root.left, K) + countNodesLessThanK(root.right, K);
    }
    return countNodesLessThanK(root.left, K);
}

Node insertIntoBST(Node root, int val) {
    if (root == null) {
        return new Node(val);
    }
    if (val < root.val) {
        root.left = insertIntoBST(root.left, val);
    } else {
        root.right = insertIntoBST(root.right, val);
    }
    return root;
}

Node[] splitIntoTwo(Node root, int leftSize, int rightSize) {
    if (root == null) {
        return new Node[]{null, null};
    }
    int leftNodes = countNodes(root.left);
    if (leftNodes < leftSize) {
        Node[] splitRight = splitIntoTwo(root.right, leftSize - leftNodes - 1, rightSize);
        root.right = splitRight[0];
        return new Node[]{root, splitRight[1]};
    } else if (leftNodes > leftSize){
        Node[] splitLeft = splitIntoTwo(root.left, leftSize, rightSize - leftNodes - 1);
        root.left = splitLeft[1];
        return new Node[]{splitLeft[0], root};
    } else {
        return new Node[]{root, root.right};
    }
}

Node balanceBST(Node root) {
    if (root == null) {
        return null;
    }
    int leftHeight = getHeight(root.left);
    int rightHeight = getHeight(root.right);
    if (leftHeight > rightHeight + 1) {
        root = balanceLeft(root);
    } else if (rightHeight > leftHeight + 1) {
        root = balanceRight(root);
    }
    root.left = balanceBST(root.left);
    root.right = balanceBST(root.right);
    return root;
}

Node balanceLeft(Node root) {
    Node left = root.left;
    int leftHeight = getHeight(left.left);
    int rightHeight = getHeight(left.right);
    if (rightHeight > leftHeight) {
        root.left = rotateLeft(left);
    }
    return rotateRight(root);
}

Node balanceRight(Node root) {
    Node right = root.right;
    int leftHeight = getHeight(right.left);
    int rightHeight = getHeight(right.right);
    if (leftHeight > rightHeight) {
        root.right = rotateRight(right);
    }
    return rotateLeft(root);
}

Node rotateLeft(Node root) {
    Node newRoot = root.right;
    root.right = newRoot.left;
    newRoot.left = root;
    return newRoot;
}

Node rotateRight(Node root) {
    Node newRoot = root.left;
    root.left = newRoot.right;
    newRoot.right = root;
    return newRoot;
}

int getHeight(Node node) {
    if (node == null) {
        return 0;
    }
    return 1 + Math.max(getHeight(node.left), getHeight(node.right));
}

总结

本篇文章介绍了如何根据值K将BST分为左右两个平衡的BST。这个算法思路比较简单，但实现起来较为复杂，需要采用递归和平衡算法来实现。需要注意的是，本算法并不保证分出的两个BST的深度一样，但可以保证它们在节点数量上是平衡的。