Three Node Constructors and Constructor Delegation

Try This First

You want to add the string "Alice" to the front of an existing singly linked list whose head reference is oldHead. Which single line of code does it cleanly?

head = new Node<>("Alice", oldHead);

What You Need To Walk In With

• A Node<T> has exactly two fields: T data and Node<T> next.
• The no-argument constructor sets both fields to null.
• The one-argument constructor sets data to the given value and next to null via constructor delegation.
• Constructor delegation means one constructor calls another in the same class using this(...) as the very first statement.
• The two-argument constructor is the canonical form: it sets both fields directly and is the one the other constructors delegate to.

How It Works

The S20 Lab 5 spec calls for exactly three constructors on Node<T>:

public class Node<T> {
    T data;
    Node<T> next;

    // No-arg: both fields null
    public Node() {
        this.data = null;
        this.next = null;
    }

    // One-arg: data set, next defaults to null via delegation
    public Node(final T data) {
        this(data, null);        // delegates to the two-arg form
    }

    // Two-arg: the canonical constructor
    public Node(final T data, final Node<T> next) {
        this.data = data;
        this.next = next;
    }
}

The key relationship is the this(data, null) call in the one-argument constructor. Java requires that a this(...) delegation appear as the very first statement in the constructor body. The compiler resolves it to the two-argument constructor at compile time, so there is no runtime overhead from the indirection.

Pointer picture after Node<String> n = new Node<>("B", null):

  n
  |
  v
+--------+------+
| "B"    | null |
+--------+------+
 data     next

After Node<String> front = new Node<>("A", n):

  front           n
  |               |
  v               v
+-------+----+   +-------+------+
| "A"   |  --+-->| "B"   | null |
+-------+----+   +-------+------+

The two-argument constructor wired the next field to point at the existing node in one step.

Worked Example: Predict, Then Check

After these three lines execute, what are n.data and n.next?

Node<String> n = new Node<>("A");

A Common Mistake

A tempting pattern when adding to the front of a list is to create a node first and then set its fields separately:

// Avoid this pattern
Node<String> temp = new Node<>();
temp.data = "X";
temp.next = head;
head = temp;

This works, but it bypasses the constructors entirely and scatters the initialization across three statements. If you later change the field names or types, every such call site breaks independently. The fix is to use the two-argument constructor:

head = new Node<>("X", head);

One line, no temporaries, and the node is fully initialized by the time the assignment to head completes. (Source: S20.Lab5-LL_NDH.LinkedList.java)

Go Deeper (optional)

Each new Node<>(...) call allocates one object on the heap: constant time and constant space. When you add to the front of the list using the two-argument form, the total cost is O(1) because no existing nodes are visited. If you are curious why some textbook designs add a dummy head node at the front, that is a separate topic covered later; this course teaches the no-dummy-head form first, where the head reference is either null (empty list) or points directly to the first real node.

Check Yourself

Close the notes and answer each one from memory, then reveal it. Pulling an idea back from memory is one of the strongest ways to make it stick.