Singly Linked List

So you want to store a list of values. But you don’t know how many you’ll have. An array makes you pick a size up front. Pick too small and you run out of room. Pick too big and you waste memory. A singly linked list fixes this. It grows one piece at a time. Each piece only knows where the next piece is.

📚 What Is a Singly Linked List?

A singly linked list is a chain of small boxes. Each box is called a node. A node holds two things.

• The actual value you want to store. This could be a number or a name.
• A link that points to the next node in the chain.

The first node is special. We keep a pointer to it called the head. The head is just the entry point to the whole list. From the head you can reach every other node. You follow the links one by one.

The last node has nowhere to go next. So its link points to nothing. In C, C++, and Java we call that nothing NULL. In Python it is None. In JavaScript it is null. The idea is the same everywhere. It just means “the chain ends here”.

Think of a treasure hunt. Riya gets the first clue. That clue tells her where the next clue is. She follows it and reads the next clue. This keeps going. The last clue says “you’re done”. The node value is the clue’s message. The link is the address of the next clue.

🎯 Why Not Just Use an Array?

Here is the pain. In an array the items sit next to each other. They live in one fixed block of memory. To add or remove from the middle, you have to shift everything around. And the size is decided early.

A linked list spreads the nodes out in memory. Each node can live anywhere. The link is what holds them together. So the trade-off looks like this.

🛠️ Steps to Build and Traverse the List

We’ll do two jobs here. First we build a small list with the values 10, 20, 30. Then we walk through it and print every value. Here is the plan.

1. Define a node that holds a value and a link to the next node.
2. Create the first node. Set its value to 10 and point the head at it.
3. Create a second node with 20. Link the first node’s next to it.
4. Create a third node with 30. Link the second node’s next to it.
5. Set the last node’s next to null so the chain ends cleanly.
6. To traverse, start at the head. Print the current value, then move to the next node. Repeat until you hit null.

When we print, we’ll show the arrows so the shape is clear. It will look like 10 -> 20 -> 30 -> NULL.

💻 Code in Five Languages

The code below defines the node. It links three nodes by hand. Then it traverses from the head and prints each value followed by an arrow.

#include <stdio.h>
#include <stdlib.h>

// A node holds a value and a link to the next node
struct Node {
    int data;
    struct Node* next;
};

// Helper to create a new node on the heap
struct Node* makeNode(int value) {
    struct Node* node = (struct Node*)malloc(sizeof(struct Node));
    node->data = value;
    node->next = NULL;
    return node;
}

// Start at head, print each value, move to next until NULL
void traverse(struct Node* head) {
    struct Node* current = head;
    while (current != NULL) {
        printf("%d -> ", current->data);
        current = current->next;
    }
    printf("NULL\n");
}

int main() {
    // Build the list: 10 -> 20 -> 30
    struct Node* head = makeNode(10);
    head->next = makeNode(20);
    head->next->next = makeNode(30);

    traverse(head);
    return 0;
}

10 -> 20 -> 30 -> NULL

#include <iostream>
using namespace std;

// A node holds a value and a link to the next node
struct Node {
    int data;
    Node* next;
};

// Helper to create a new node
Node* makeNode(int value) {
    Node* node = new Node();
    node->data = value;
    node->next = nullptr;
    return node;
}

// Start at head, print each value, move to next until null
void traverse(Node* head) {
    Node* current = head;
    while (current != nullptr) {
        cout << current->data << " -> ";
        current = current->next;
    }
    cout << "NULL" << endl;
}

int main() {
    // Build the list: 10 -> 20 -> 30
    Node* head = makeNode(10);
    head->next = makeNode(20);
    head->next->next = makeNode(30);

    traverse(head);
    return 0;
}

10 -> 20 -> 30 -> NULL

public class SinglyLinkedList {

    // A node holds a value and a link to the next node
    static class Node {
        int data;
        Node next;

        Node(int value) {
            this.data = value;
            this.next = null;
        }
    }

    // Start at head, print each value, move to next until null
    static void traverse(Node head) {
        Node current = head;
        while (current != null) {
            System.out.print(current.data + " -> ");
            current = current.next;
        }
        System.out.println("NULL");
    }

    public static void main(String[] args) {
        // Build the list: 10 -> 20 -> 30
        Node head = new Node(10);
        head.next = new Node(20);
        head.next.next = new Node(30);

        traverse(head);
    }
}

10 -> 20 -> 30 -> NULL

# A node holds a value and a link to the next node
class Node:
    def __init__(self, value):
        self.data = value
        self.next = None

# Start at head, print each value, move to next until None
def traverse(head):
    current = head
    while current is not None:
        print(current.data, "-> ", end="")
        current = current.next
    print("NULL")

# Build the list: 10 -> 20 -> 30
head = Node(10)
head.next = Node(20)
head.next.next = Node(30)

traverse(head)

10 -> 20 -> 30 -> NULL

// A node holds a value and a link to the next node
class Node {
  constructor(value) {
    this.data = value;
    this.next = null;
  }
}

// Start at head, print each value, move to next until null
function traverse(head) {
  let current = head;
  let result = "";
  while (current !== null) {
    result += current.data + " -> ";
    current = current.next;
  }
  result += "NULL";
  console.log(result);
}

// Build the list: 10 -> 20 -> 30
const head = new Node(10);
head.next = new Node(20);
head.next.next = new Node(30);

traverse(head);

10 -> 20 -> 30 -> NULL

⏱️ How Fast Is It?

Traversing means visiting every node once from head to end. If there are n nodes, you do n steps. So traversal is O(n).

Now what about reading the value at a position? Say you want the 5th node. In an array that is instant. In a linked list you can’t jump. You have to start at the head and follow the links five times. So access by index is also O(n).

⚠️ Common Mistakes

A few slips trip up almost everyone the first time.

• Forgetting to set the last node’s next to null. Then traversal never stops. Your program reads garbage memory or loops forever.
• Losing the head pointer. If you move the head forward while building, you lose the start of the list and can’t get back to it. Use a separate current pointer to walk.
• Reading next on a null node. Once current becomes null, the list is over. Trying to read current.next after that crashes.
• Assuming you can jump to the middle like an array. You can’t. Always start from the head and follow links.

🧩 What You’ve Learned

✅ A singly linked list is a chain of nodes. Each node holds a value and a link to the next node.

✅ The head pointer is the entry point. The last node’s next points to null to mark the end.

✅ You build a list by creating nodes and setting each node’s next to the following node.

✅ You traverse by starting at the head and following next until you reach null.

✅ Traversal is O(n). Access by index is O(n) too, because there’s no way to jump straight to a position.

🚀 What’s Next?

You can build a list and walk through it now. Next, let’s learn how to add and find nodes.

• Introduction to Linked Lists steps back to see how nodes and links work and where linked lists fit among data structures.
• Insert a Node in a Linked List shows how to add a node at the front, the end, or any position.