ArrayList 正在替换项目而不是将其添加到末尾

Question

I have a method that finds a node in a linked list with a certain id and adds items to the arraylist of that node.

ArrayList <String> elems;

public Place addElemToLst(String id, String elem) {
        
            // if no nodes create new node
            if (head == null) { 
                Node node = new Node(id);
                node.elems.add(item);
                head = unit;
            } else if (head != null) {
                Node curr = head;
                while (curr.next != null && !curr.next.id.equals(id)) {
                    curr = curr.next;
                }
                // if there is a id match
                if (curr.id.equals(id)) {
                    curr.elems.add(item);
                }
                // add new Node
                else { // the error is in this section
                    Node node = new Node(id);
                    node.elems.add(elem); 
                    curr.next = node;
                    
                }
        
        }

        return this;
    }

The problem is when I call addElemToLst() on an id of lets say "item1" multiple times and keep adding elements to the arraylist, the arraylist will only keep the last item entered into the arraylist. Essential, the arraylist is always a size of 1 because previous entries keep getting replaced. Why is this and what is the error? I have isolated the error to the comment in the code. Thanks

Answer 1

You are not checking the first element/head for the correct ID

 while (curr.next != null && !curr.next.id.equals(id))

You can try something like this for the second half:

else {
        Node curr = head;
        Node prev = null;
        while(curr != null){                
            if(curr.id == id){
                curr.elems.add(elem);
                return this;
            }
            prev = curr;
            curr = curr.next;
        }
            Node node = new Node(id);
            node.elems.add(elem);
            prev.next = node;

        }
}

Answer 2

Your approach to finding a node with a matching ID will return a few different false negatives, which will in turn cause existing nodes to be overwritten. The issue is that you're using a sliding window to inspect nodes and determine a match, but your criteria for sliding doesn't line up with your criteria for determining whether to append to an existing node or create a new node.

Here are a few examples to illustrate:

  _ = null
  x = node
  o = node with matching ID
[ ] = sliding window (left side is `curr`, right side is `curr.next`)

x -> o -> _
[    ]

Since the matching node is at the end of the list, you should append
`elem` to it. However, your code checks `curr.id` (instead of `curr.next.id`),
incorrectly concludes that no matching node is found, and overwrites `curr.next`.

o -> x -> _
[    ]
     [    ]

Here, the matching node is at the head of the list, but your code
skips it and incorrectly creates a new node at the end of the list.

o -> x -> x -> _
[    ]
     [    ]
          [     ]
Same as above, a new node is incorrectly inserted at the end of
the list since you skipped the matching node at the head of the list.

x -> o -> x -> _
[    ]

Since you're checking `curr.id` (instead of `curr.next.id`), your code
incorrectly concludes that a new node needs to be created, overwriting
the existing (matching) node and truncating the tail of the list.

Linked lists are tough to reason about, and combining while conditions makes it even more difficult to grok. Here is a fixed implementation that (IMO) is easier to reason about:

public Place addElemToLst(String id, String elem) {
    // if the list is empty, create a new node
    if (head == null) {
        Node node = new Node(id);
        node.elems.add(elem);
        head = node;
        return this;
    }

    Node curr = head;
    while (curr.next != null) {
        // if the matching node appears inside the list,
        // append the element and return
        if (curr.id.equals(id)) {
            curr.elems.add(elem);
            return this;
        }

        curr = curr.next;
    }

    // if the last node in the list is a match, use it
    if (curr.id.equals(id)) {
        curr.elems.add(elem);
    // now that you've exhausted all nodes, create a new one
    } else {
        Node node = new Node(id);
        node.elems.add(elem);
        curr.next = node;
    }

    return this;
}