如何在二叉搜索树数组实现中找到最大值的索引？

Question

我有三个看起来像这个示例的数组：

left 和 right 数组是当前索引的左右孩子的索引号。 如果任一持有 -1，该孩子不存在。 如果两者都保持 -1，则索引处的节点是叶节点。 我知道这在现实世界中实施并没有什么意义，但这是一项任务。

无论如何，我试图在实现这个想法的类中实现一个 remove 方法。 除了节点有两个孩子的情况外，我让它适用于所有情况。 我的问题是我正在调用一个递归方法（我创建的所有方法都必须是递归的），该方法应该返回包含我要删除的节点左子树中最大节点的索引。 我需要这个，因为这是将用正在删除的两个子节点替换节点的节点。

我当前的代码返回它在子树中看到的第一个节点的索引，因为我的返回基本上被覆盖了。 看这里：

//find largest node in left subtree and return its index
private int findNew(int index) {
    int r = right[index];
    if(r != -1) {
        findNew(r);
    }
    return index;
}

这是我实现的删除方法：

private void remove(int d, int index) {
    //we found the data to remove
    if(data[index] == d){
    //removes
        //if the node is a leaf
        if(left[index] == -1 && right[index] == -1) {
            data[index] = -1;
            if(free == -1) {
                free = index;
            } else {
                freeUpdate(index);
            }
            currentSize--;
        }
        //the node has a left child
        else if(left[index] != -1 && right[index] == -1) {
            int l = left[index];
            data[index] = data[l];
            left[index] = left[l];
            right[index] = right[l];
            if(free == -1) {
                free = l;
            } else {
                freeUpdate(l);
            }
            //delete stuff in node that moved
            data[l] = -1;
            right[l] = -1;
            currentSize--;
        }
        //the node has a right child
        else if(left[index] == -1 && right[index] != -1) {
            int r = right[index];
            data[index] = data[r];
            left[index] = left[r];
            right[index] = right[r];
            if(free == -1) {
                free = r;
            } else {
                freeUpdate(r);
            }
            //delete stuff in node that moved
            data[r] = -1;
            right[r] = -1;
            currentSize--;
        }
        //the node has two children
        else {
            int l = left[index];
            int r = right[index];
            int newParent = findNew(l);
            //implement the rest of the remove here
            currentSize--;
        }
    } else {
        //if we have searched the entire tree
        if(index == data.length) {
            return;
        } else {
            //keep searching for d
            remove(d, index + 1);
        }
    }
}

类的属性和构造函数：

private int root;
private int free;
private int left[];
private int data[];
private int right[];
private int currentSize;

public BoundedBST(int size) {
    root = -1;
    free = -1;
    left = new int[size];
    data = new int[size];
    right = new int[size];
    currentSize = 0;
}

public boolean full() {
    return free == -1 && currentSize == data.length;
}

我再次知道这个实现没有多大意义，但这就是我正在使用的。 我知道使用循环可以很容易地完成 findNew 方法，但我不能在这里这样做。

本质上，我只是想找到一种方法，让我的 findNew 方法递归工作，而不会覆盖上次调用返回的内容。 我理解这里发生的错误，但我不知道如何实现这样一个仍然可以具有非 void 返回类型的函数。

Answer 1

findNew的问题在于，当您进行递归调用时，您不会对递归调用返回的内容做任何事情。 该值将被忽略，并且您在所有情况下都返回index 。 这使得递归调用无用。

您实际上应该捕获该返回值，并将其再次返回给调用者，以便该索引从递归调用中冒泡出来，直到它到达原始调用者。

我还建议给这个函数一个更具描述性的名称： findGreatest ：

private int findGreatest(int index) { // Use a better name
    int r = right[index];
    if (r != -1) {
        return findGreatest(r); // Must do something with the value returned!
    }
    return index;
}

这解决了您询问的问题。 但是你仍然需要完成你写的“在此处实现其余的删除”部分。 我建议你在这方面努力。 如果您在执行此操作时遇到特定问题，请随时提出有关该问题的新问题。

最后，在决定一切都好之前，请确保在许多不同的场景下彻底测试您的解决方案。