Linked List Visualizer

How it works

1. Each node holds data and a next pointer. The list itself only stores head, the address of the first node (plus tail if it keeps one).
2. The last node's next is NULL, which marks the end. An empty list is simply head = NULL.
3. Traverse: start with curr = head and repeat curr = curr.next until curr is NULL. Search, length and printing all work this way.
4. Insert after a node: allocate the new node, set new.next = curr.next first, then curr.next = new. Inserting at the head is the same move with head in place of curr.next.
5. Delete after a node: set prev.next = prev.next.next and free the unlinked node. Deleting the head just moves head one node forward.

Linked list vs array

An array keeps its elements in one contiguous block, so element i lives at base + i × size: O(1) access. A linked list gives that up — its nodes are allocated one at a time wherever memory is free, tied together only by next pointers — and gets cheap structural change in return. Once you stand on the right node, inserting or deleting rewires two pointers and moves nothing else, and the list never needs resizing.

• Access by index: array O(1), linked list O(n).
• Insert or delete at the front: array O(n) (everything shifts), linked list O(1).
• Insert or delete in the middle: both need O(n) to reach the spot; after that the list is O(1) and the array O(n).
• Memory and speed: every node also stores one or two pointers (8 bytes each on a 64-bit machine), and scanning scattered nodes misses the CPU cache — so lists are often slower in practice even when the big-O matches.

Singly, doubly and circular linked lists

The three classic variants differ only in which pointers each node carries, but that decides which operations are cheap.

• Singly linked list — [data | next]. The lightest, and forward-only. Deleting a node needs its predecessor, so deleting the tail is O(n) even with a tail pointer.
• Doubly linked list — [prev | data | next]. One more pointer per node buys backward traversal and O(1) deletion of any node you hold; with the usual head and tail pointers both ends are O(1). Inserts write four pointers instead of two.
• Circular linked list — the last node points back to the head. A pointer to the last node reaches both ends in O(1), which suits round-robin scheduling; loops stop when they return to the head.

Use singly for a stack, or a queue with a tail pointer; doubly when you remove arbitrary nodes or walk both ways (an LRU cache); circular when the data really is a ring. The List type switch above converts the list on screen so you can compare them.

Worked example: insert 99 at index 2

Take the list the visualizer opens with: 12 → 7 → 33 → 5 → 21 → 48 → NULL. To put 99 at index 2 you need the node before that position — index 1, value 7 — so walk one step from the head: curr = head (12), then curr = curr.next (7).

Now two pointer writes, in this order:

• new.next = curr.next — 99 now points at 33. Nothing in the list has changed yet; 99 is just aiming at the right place.
• curr.next = new — 7 now points at 99, and the list reads 12 → 7 → 99 → 33 → 5 → 21 → 48.

The order is the whole trick. Do the second write first and 7.next is overwritten before anyone saved the address of 33: the nodes 33, 5, 21 and 48 become unreachable — a memory leak in C, silently lost data everywhere else. The Wrong order button in the visualizer plays exactly that mistake so you can watch the rest of the list fall away.

Common linked list mistakes

• Losing the rest of the list by overwriting a next pointer before saving it.
• Dereferencing NULL — reading curr.next.data on the last node, or running any operation on an empty list.
• Forgetting the head or tail pointer when the node you insert or delete sits at either end. Test with 0, 1 and 2 nodes.
• Off-by-one walks — to insert at index i, stop on node i − 1, not on node i.

A dummy (sentinel) node in front of the real head gives every real node a predecessor, so insert and delete need no if index == 0 branch.

Where linked lists are used

Linked lists rarely beat a dynamic array for plain storage, but they shine when elements must be spliced in and out without moving anything else:

• LRU caches pair a hash map with a doubly linked list, so "move to front" and "evict the oldest" are both O(1).
• Stacks and queues — a singly linked list with head (and tail) pointers gives O(1) push, pop and enqueue with no resizing.
• Graph adjacency lists, hash-table buckets with separate chaining, and the free lists inside memory allocators.
• Operating-system kernels — Linux links processes, timers and devices with an intrusive circular doubly linked list (list_head).
• Standard libraries — Java's LinkedList and C++'s std::list are doubly linked; Python's collections.deque is a doubly linked list of fixed-size blocks.

Linked lists in coding interviews

Most interview problems combine four moves, each animated on this site: reverse in place with three pointers; slow and fast pointers to find the middle or detect a cycle (Floyd's tortoise and hare); a dummy head to merge sorted lists or delete without special cases; and gap pointers to remove the k-th node from the end.

Interviewers mostly check the empty list, the one-node list, and the head and tail. Narrate each pointer write in order, exactly as the status line above does.

Time and space complexity

Linked List in Python

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None  # next node


class LinkedList:
    def __init__(self):
        self.head = None  # first node

    def insert_at_head(self, value):
        new_node = Node(value)
        new_node.next = self.head
        self.head = new_node

    def insert_at_tail(self, value):
        new_node = Node(value)
        if self.head is None:
            self.head = new_node
            return
        curr = self.head
        while curr.next is not None:
            curr = curr.next
        curr.next = new_node

    def search(self, value):
        curr, i = self.head, 0
        while curr is not None:
            if curr.data == value:
                return i
            curr, i = curr.next, i + 1
        return -1

    def delete_head(self):
        if self.head is None:
            raise IndexError("delete from empty list")
        temp = self.head
        self.head = self.head.next
        del temp  # free(temp): the GC reclaims it

    def delete_value(self, value):
        if self.head is None:
            return False
        if self.head.data == value:
            self.delete_head()
            return True
        prev = self.head
        while prev.next is not None:
            if prev.next.data == value:
                break
            prev = prev.next
        if prev.next is None:
            return False  # not found
        temp = prev.next
        prev.next = temp.next
        del temp  # free(temp): the GC reclaims it
        return True

The visualizer above shows the same code in Python, C++, Java and JavaScript.

Frequently asked questions

Keep learning

• Doubly Linked List VisualizerDoubly linked list visualizer: see prev and next pointers rewired as you insert, delete and reverse, learn why tail delete is O(1), with Python code and FAQs.
• Circular Linked List VisualizerCircular linked list visualizer: the last node points back to the head. See O(1) insert at both ends with a tail pointer, safe traversal and real-world uses.
• Reverse a Linked List — Step by StepReverse a linked list in place with three pointers. Watch every arrow flip step by step and compare iterative vs recursive code — O(n) time, O(1) space.
• Floyd's Cycle Detection VisualizerFloyd's cycle detection (tortoise and hare) finds a loop in a linked list with two pointers and the node where it starts. Step through both phases to see why.
• Stack & Queue VisualizerStack and queue visualizer: animate push, pop, enqueue and dequeue, compare LIFO with FIFO, and step through circular queues, deques and stack applications.