LinkedList-试图了解实现

Question

I am learning to solve complex algorithm. For that I came across the implementation for LinkedList. I am trying to understand the above solution. In appendToTail I don't understand while loop and the line after the while loop. In deleteNode I cannot see where the node is deleted.

class Node {
    Node next = null;
    int data;

    public Node(int d) {
        data = d;
    }

    void appendToTail(int d) {
        Node end = new Node(d);
        Node n = this;
        while (n.next != null) {
            n = n.next;
        }
        n.next = end;
    }

    Node deleteNode(Node head, int d) {
        Node n = head;
        if (n.data == d) {
            return head.next; /* moved head */
        }
        while (n.next != null) {
            if (n.next.data == d) {
                n.next = n.next.next;
                return head; /* head didn’t change */
            }
            n = n.next;
        }
   }
}

Answer 1

Well here are two cases to consider: First, when the node is the first in the list. Then the head is just moved to the next node and the first node is no longer part of the list.

In the second case, we just iterate over the whole list node by node. If we reach the node, whose next node needs deletion (which is checked by the if statement), it is changed to hold the node after the deleted node as next node (first line within the if statement). This removes the node from the list. Here the head stays the same, as changing it would remove all elements before the node that is supposed to be deleted (if it was changed to the node after the deleted one).

When the node b is supposed to be deleted, all the node a has to do is to point to the node after b ( c ). This is how the list would look:

... a -> b -> c -> ...  // before deletion
... a -> c -> ...       // after deletion, now a points to c

For a explanation with nicer visualization you can check here . The general case part is where the second case is described. The disposal of the removed isn't done explicitly in the implantation, as it is performed by the garbage collector.

Answer 2

LinkedLists have several implementations. Some keep only a pointer to the head of the list. Others keep track of the tail to accomplish appending to tail in O(1)

This implementation maintains no tail pointer, so you have to iterate through the list starting from the head

1 --> 2 --> null
^
head

So this refers to the head of the list. The while loop moves through the list until it reaches the end or (until the next node pointer in n equals null)

In the above example the loop would terminate here

n  n.next
2   null

The loop would then exit and set:

n.next = end

The new list looks like this:

1 --> 2 --> 3
^
head