Question

我在使用add方法时遇到麻烦，我相信在public方法中传递的参数中会发生错误，但是我不确定我的私有助手方法是否也未添加正确的变量。

这是我的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;
}

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

1 个答案: