将元素插入到具有最终成员的不可变 LinkedList

如何解决将元素插入到具有最终成员的不可变 LinkedList

我需要帮助来实现将新子项和兄弟项添加到 Trie 的插入方法。我看到了很多解决方案。但是，我的问题有所不同，因为类中的类成员是 final 的，因此在遍历树时无法引用下一个元素。我在互联网上搜索了很多，但似乎找不到任何帮助。我已经为此苦苦挣扎了两天。就我而言，我不能将 current.sibling 分配给 newEntry，因为兄弟是最终的。所以我需要找到另一种向 Trie 添加新元素的方法，我必须坚持使用以下抽象类。有人建议我应该为每个新元素创建新对象，我实现了它，但我不知道为什么代码没有给出正确的结果。

我将在下面分享我的代码。

任何帮助将不胜感激

正如您在下面的代码中看到的那样，兄弟成员等成员是最终成员。

public abstract class AbstractTrieChildren implements Iterable<AbstractTrieChildren> {
    /**
     * The label of the outgoing edge.
     */
    protected final char character;
    /**
     * The target of the outgoing edge.
     */
    protected final AbstractTrie child;
    /**
     * The reference to the next sibling or {@code null} if none.
     */
    protected final AbstractTrieChildren sibling;

    public AbstractTrieChildren(char character,AbstractTrie child,AbstractTrieChildren sibling) {
        this.character = character;
        this.child = child;
        this.sibling = sibling;
    }

    /**
     * Adds a new labelled edge ({@link #character},{@link #child}) to the <b>sorted</b> traversable linked list of siblings iff there is no such edge.
     * If an entry already exists,then this method leaves the list unchanged.
     *
     * @param character the label of the possibly new labelled edge to insert
     * @param child     the target trie of the possibly new labelled edge to insert
     * @return the new head (left-most node) of the <b>sorted</b> traversable linked sibling list
     */
    public abstract AbstractTrieChildren insertSorted(char character,AbstractTrie child);
}

以下是我尝试过的所有插入方法。我不知道为什么它没有给出正确的结果。我尝试使用递归方法，如果不存在元素，则添加一个新元素，否则将元素添加到兄弟元素，但它只添加了两个元素

public AbstractTrieChildren insertSorted(char character,AbstractTrie child) {
        AbstractTrieChildren current = this;


        if (character < this.character) {
            return new TrieChildren(current.character,current.child,null);
        }
        else if (character > this.character) {
            return new TrieChildren(current.character,new TrieChildren(character,child,null));

        } else {
            return insertSorted(character,child);
        }
}

解决方法

你所拥有的令人困惑。我将通过类比来解决您的问题，因为我无法 100% 确定您要完成什么（例如，什么是 AbstractTrieChildren 与 AbstractTrie 等）。

假设我们想要使用基于递归的插入方法来实现一个不可变的链表。

我们的节点：

public class Node<T> {
  final Node next;
  final T value;
  public Node(T value,Node next) {
    this.next = next;
    this.value = value;
  }

由于我们无法更新 next，我们需要通过创建列表的末尾而不是开头来开始插入操作。

public Node insertAtEnd(Node current,T newValue) {
  if (current == null) {
    // Base case,we're at the end of the list.
    return new Node(newValue,null);
  } else {
    // Recursive case,get the next node and create a node pointing to it.
    Node newNext = insertAtEnd(current.next,newValue);
    return new Node(this.value,newNext);
  }
}

看一个例子：

• 列表最初是 (head) 1 -> 2 -> 3 -> null。
• 致电insertAtEnd(head (1),4)。
• current 不为空，调用 insertAtEnd(current.next (2),4)。
  • current 不为空，调用 insertAtEnd(current.next (3),4)。
    • current 不为空，调用 insertAtEnd(current.next (null),4)。
      • current 为空，返回 new Node(4,null)。
    • 返回 new Node(3,newNext (4))。
  • 返回 new Node(2,newNext (3))。
• 返回 new Node(1,newNext(2))。
• 返回的节点现在是 (head') 1 -> 2 -> 3 -> 4 -> null。
• 最初的 head 仍然是 1 -> 2 -> 3 -> null，因为它是不可变的，所以没有改变。

你所拥有的更像是这样（类比）：

public Node insertAtEnd(Node current,T newValue) {
  if (current == null) {
    return new Node(newValue,null);
  }
  else {
    return insertAtEnd(current,newValue);
  }
}

您只是在不修改输入的情况下以递归方式调用该方法，并且您并未通过递归调用构建任何结构。

有意义吗？

您的示例更复杂，但您需要做的是为递归步骤添加更多结构。就像一个不可变链表一样，您需要递归地向下迭代原始的特里树结构，然后向后构建新的特里树结构，从叶子开始，再回到根。

至于您应该在哪里使用 [Abstract]TrieChildren 和 [Abstract]Trie 的具体细节，我不确定。