BST隐藏测试用例失败排查求助：已测常见边缘情况仍未定位问题

各位大佬好，我现在在实现二叉搜索树（BST）的几个操作时，遇到了一个头疼的问题：一些隐藏测试用例始终无法正确输出。我已经把能想到的边缘情况都测了一遍，但还是找不到问题所在，想请大家帮忙看看哪里出了问题？

已测试的边缘情况： #

• 不存在的键删除：我假设输入是符合问题描述的合法输入
• 空树操作：已经通过根节点的检查处理了
• 最大键的后继：假设输入保证该键存在后继
• 删除根节点：所有情况都正确调整了根指针
• 只有一个节点的树：delete和minKey方法都表现正常

我怀疑问题出在下面这些方法里，贴出代码供大家参考：

public void delete(int k) {
        Node nodeToDelete = getDescendant(root, k);

        // Case 1: Node has no children (leaf node)
        if (nodeToDelete.left == null && nodeToDelete.right == null) {
            if (nodeToDelete == root) {
                root = null;
            } else if (nodeToDelete.parent.left == nodeToDelete) {
                nodeToDelete.parent.left = null;
            } else {
                nodeToDelete.parent.right = null;
            }
        }
        // Case 2: Node has one child
        else if (nodeToDelete.left == null || nodeToDelete.right == null) {
            Node child = (nodeToDelete.left != null) ? nodeToDelete.left : nodeToDelete.right;

            if (nodeToDelete == root) {
                root = child;
            } else if (nodeToDelete.parent.left == nodeToDelete) {
                nodeToDelete.parent.left = child;
            } else {
                nodeToDelete.parent.right = child;
            }
            child.parent = nodeToDelete.parent;
        }
        // Case 3: Node has two children
        else {
            Node successor = minDescendant(nodeToDelete.right);
            int successorKey = successor.key;
            delete(successorKey); // Remove the successor
            nodeToDelete.key = successorKey; // Replace node's key with successor's key
        }
    }

    private Node minDescendant(Node n) {
        Node current = n;
        while (current.left != null) {
            current = current.left;
        }
        return current;
    }

    public int successorKey(int k) {
        Node node = getDescendant(root, k);

        // Case 1: Node has a right subtree
        if (node.right != null) {
            return minDescendant(node.right).key;
        }

        // Case 2: No right subtree; move up to find the successor
        Node ancestor = node.parent;
        while (ancestor != null && node == ancestor.right) {
            node = ancestor;
            ancestor = ancestor.parent;
        }
        return ancestor.key;
    }

    public int minKey() {
        return minDescendant(root).key;
    }


    /* Part (b) methods */

    public int medianKey() {
        List<Integer> sortedKeys = new ArrayList<>();
        inOrderTraversal(root, sortedKeys);

        // Median key is the middle of the sorted keys
        int n = sortedKeys.size();
        return sortedKeys.get((n - 1) / 2);
    }

    private void inOrderTraversal(Node node, List<Integer> keys) {
        if (node == null) return;
        inOrderTraversal(node.left, keys);
        keys.add(node.key);
        inOrderTraversal(node.right, keys);
    }


    /* Part (c) methods */

    public int nodesInLevel(int h) {
        return countNodesAtLevel(root, h, 0);
    }

    private int countNodesAtLevel(Node node, int targetLevel, int currentLevel) {
        if (node == null) return 0;
        if (currentLevel == targetLevel) return 1;

        int leftCount = countNodesAtLevel(node.left, targetLevel, currentLevel + 1);
        int rightCount = countNodesAtLevel(node.right, targetLevel, currentLevel + 1);

        return leftCount + rightCount;
    }

麻烦大家帮忙看看有没有我没考虑到的边缘情况，或者代码里的逻辑错误？谢谢各位了！

备注：内容来源于stack exchange，提问作者Hyungwon Shim