如何在 Java 中使用 BinarySearchTree 创建 add 方法？

Question

我的 add 方法有问题，我认为错误发生在公共方法中传递的参数中，但是我不确定我的私有帮助方法是否也没有添加正确的变量。

这是我的 addMethod 的说明

add(E) 方法可以额外调用 assignFirst() 方法来分配第一个属性，以防它应该被更改。 add helper 方法现在应该在创建新节点时分配每个节点的“父”和“下一个”引用。

• “parent”参数应该引用一个新创建的节点的父节点，所以当 创建一个新节点，您可以简单地将其父节点分配给此参数。

• “prev”参数应该引用一个新创建的节点的前一个节点，所以当 创建一个新节点，您可以简单地更新相应的“下一个”引用 节点。棘手的部分是知道在调用 add 时要传递哪些值 辅助方法。逻辑如下：

• 如果添加助手返回值是一个右孩子，那么该右孩子的前一个 节点应该与其父节点相同。可选的 getPrevNode 不会有帮助 在这里，因为前一个节点将是新节点的父节点，而新节点不是 还附在树上。

• 如果添加助手返回值是左孩子，则该左孩子的前一个节点 可以由可选的 getPrevNode 方法确定，询问它的节点 在当前节点参数之前。

这是我的代码：

public void add(E value)
{
    this.root = add(root, value, root, null);
    assignFirst();
}
// post: value added to tree so as to preserve binary search tree
private BSTNode<E> add(BSTNode<E> node, E value, BSTNode<E> parent, BSTNode<E> prev)
{
    if (node == null)
    {
        node = new BSTNode<E>(value);
        node.parent = parent;
        node.next = prev;

        this.numElements++;
    }
    else if (node.data.compareTo(value) > 0)
    {
        node.left = add(node.left, value, node , getPrevNode(node));
    }
    else if (node.data.compareTo(value) < 0)
    {
        node.right = add(node.right, value, node, node.parent);
    }
    return node;
}
private void assignFirst()
{
    BSTNode<E> node = root;
    while(node.left != null)
    {
        node = node.left;
    }
    first = node;
}
 private BSTNode<E> getPrevNode(BSTNode<E> node)
{
    if(node.left != null)
    {
        node = node.left;
        while(node.right != null)
        {
            node = node.right;
        }
        return node;
    }
    else if(node.parent != null)
    {
        if(node.parent.right == node)
        {
            return node.parent;
        }
        if(node.parent.left == node)
        {
            while(node.parent != null && node.parent.left == node)
            {
                node = node.parent;
            }
            if(node == root)
            {
              return null;
            }
            else
            {
              return node.parent;
            }
        }
    }
    return null;
}

这里有一些背景信息，但是我留下了一些方法，因为它们与我要弄清楚的内容无关。因此，我将其缩短。

public class BinarySearchTree<E extends Comparable<E>>
{
private BSTNode<E> root; // root of overall tree
private int numElements;
private BSTNode<E> first;
// post: constructs an empty search tree
public BinarySearchTree()
{
    this.root = null;
    this.numElements = 0;
}
 public class Iterator
{
    private BSTNode<E> currentNode;

    public Iterator()
    {
        currentNode = first;
    }

    public boolean hasNext()
    {
        return currentNode != null;
    }

    public E next()
    {
        E value = currentNode.data;
        currentNode = currentNode.next;
        return value;
    }
}
private static class BSTNode<E>
{
    public E data;
    public BSTNode<E> left;
    public BSTNode<E> right;
    public BSTNode<E> parent;
    public BSTNode<E> next;

    public BSTNode(E data)
    {
        this(data, null, null, null, null);
    }

    public BSTNode(E data, BSTNode<E> left, BSTNode<E> right, BSTNode<E> parent, BSTNode<E> next)
    {
        this.data = data;
        this.left = left;
        this.right = right;
        this.parent = parent;
        this.next = next;
    }
  }
}

Answer 1

这是一个严格的过程，这就是我得到的

public void add(E value)
{
    this.root = add(root, value, root, null);
    assignFirst();
}
// post: value added to tree so as to preserve binary search tree
private BSTNode<E> add(BSTNode<E> node, E value, BSTNode<E> parent, BSTNode<E> prev)
{
    if (node == null)
    {
        node = new BSTNode<E>(value);
        node.parent = parent;
        if(prev == null)
        {
            node.next = parent;
        }
        else
        {
            node.next = prev.next;
            prev.next = node;
        }
        this.numElements++;
    }
    else if (node.data.compareTo(value) > 0)
    {
        node.left = add(node.left, value, node , getPrevNode(node));
    }
    else if (node.data.compareTo(value) < 0)
    {
        node.right = add(node.right, value, node, node);
    }
    return node;
}