Singly Linked Lists

A singly linked list is a chain of items where each item points to the next one.

Each item in the chain is called a node — a small container that holds two things:

1. The actual value you want to store (a number, a word, anything)
2. A pointer to the next node

A pointer is just the location of where something is stored in memory. Think of it like a sticky note that says "the next item is stored at location 42."

The very last node has no next node, so its pointer is set to null — meaning "nothing here, the chain ends."

The list itself only needs to remember one thing: where the first node is. We call this the head. If you lose the head, you lose the whole list.

Each box above is a node. The left side holds the value, the right side holds the pointer to the next node. The last node points to null.

The Node Structure

Every linked list is built from nodes. Here is what a single node looks like:

structure Node:
    data    // the value stored in this node
    next    // pointer to the next Node (or null)

That is the entire building block. Everything else — inserting, deleting, searching — is just manipulating these nodes and their next pointers.

Creating a Linked List by Hand

Let us build the list 10 -> 20 -> 30 step by step:

// Step 1: Create three standalone nodes
nodeA = new Node(10)    // [10|null]
nodeB = new Node(20)    // [20|null]
nodeC = new Node(30)    // [30|null]
​
// Step 2: Wire them together
nodeA.next = nodeB      // [10|*]-->[20|null]
nodeB.next = nodeC      // [10|*]-->[20|*]-->[30|null]
​
// Step 3: Set head
head = nodeA

After these steps, starting from head and following .next pointers gives us the full sequence: 10, 20, 30.

How It Compares to an Array

An array lets you jump straight to element 5 by index. A linked list cannot do this — you have to start at the head and follow pointers one by one until you get there.

Traversal

To visit every node, you start at head and follow pointers until you hit null. Here is a concrete example with the list 10 -> 20 -> 30:

current = head          // current points to [10]
visit 10
current = current.next  // current now points to [20]
visit 20
current = current.next  // current now points to [30]
visit 30
current = current.next  // current is now null — stop!

In code, that loop looks like this:

function traverse(head):
    current = head
    while current is not null:
        process(current.data)
        current = current.next

This is O(n) — you visit each of the n nodes exactly once.

The Linked List Wrapper

In practice, you often wrap the head pointer in a structure:

structure LinkedList:
    head = null
    size = 0

This gives you a clean place to keep track of things. When the list is empty, head is null and size is 0.

Memory Layout Visualization

In an array, elements sit side by side:

Array:  [10][20][30][40]   <- all next to each other
         0   1   2   3    <- direct index access

In a linked list, nodes can be anywhere in memory:

The next pointer stores the location of the next node. The nodes could be far apart — it does not matter as long as the pointers are correct.

Example 1: Counting Nodes

function countNodes(head):
    count = 0
    current = head
    while current is not null:
        count = count + 1
        current = current.next
    return count

For the list 10 -> 20 -> 30, this returns 3.

Example 2: Finding a Value

function contains(head, target):
    current = head
    while current is not null:
        if current.data equals target:
            return true
        current = current.next
    return false

Example 3: Getting the Last Node

function getLast(head):
    if head is null:
        return null
    current = head
    while current.next is not null:
        current = current.next
    return current

Notice the subtle difference: we check current.next (not current) so we stop AT the last node rather than going past it.

Here is a complete JavaScript implementation you can run right here. It covers creating a linked list, appending, prepending, deleting, searching, and traversing.