Linked Structures

Build a Singly Linked List

Construct a singly linked list by allocating one node per value and chaining next references. Establishes the node + head + tail model used by every later linked-list lesson.

Algorithm

Basic Implementation

basic.js 
class Node {
    constructor(value) {
        this.value = value;
        this.next = null;
    }
}

const values = [10, 20, 30, 40];
let head = null;
let tail = null;
for (const v of values) {
    const node = new Node(v);
    if (head === null) {
        head = node;
    } else {
        tail.next = node;
    }
    tail = node;
}

The canonical values [10, 20, 30, 40] become one node per value. The head pointer names the first node; the tail pointer names the last node appended.

Step 1 - First node

After appending 10, both head and tail point at the same node.

Start of the chain: head and tail both reach node(10).headtailnode(10)null

Step 2 - Append through 30

Each append changes the old tail's next pointer, then moves tail to the new node.

After appending 20 and 30: tail names node(30).headnode(10)node(20)node(30)tailnull

Step 3 - Final chain

Appending 40 gives the lesson's pinned chain: head -> 10 -> 20 -> 30 -> 40 -> null.

Complete linked list for [10, 20, 30, 40].headnode(10)node(20)node(30)node(40)tailnull

Complexity

  • Time: O(n) with a tail pointer
  • Space: O(n) for the chain

Implementation notes

  • JavaScript: a small class Node is the idiomatic Node.
  • The replay never shows runtime references; nodes are labelled node(<value>) and the chain view is rendered as 10 -> 20 -> ... -> null.
node chain Each `Node` carries a `value` and a `next` reference (or `null`).