The selling point of linked lists in comparison to arrays is that inserting or removing elements can be cheap: at the front of the list, inserting a new element just requires allocating another struct and hooking up a few pointers, while removing an element just requires moving the pointer to the first element to point to the second element instead, and then freeing the first element.

For example here’s what happens the linked list above looks like after we insert a new element at the front:

Linked list after insertion

To make this work, we need to change two pointers: the head pointer and the next pointer in the new element holding 0. These operations aren’t affected by the size of the rest of the list and so take O(1) time.

Removal is the reverse of installation: We patch out the first element by shifting the head pointer to the second element, then deallocate it with free. (We do have to be careful to get any data we need out of it before calling free). This is also an O(1) operation.

The fact that we can add and remove elements at the start of linked lists for cheap makes them particularly useful for implementing a stack, an abstract data type that supports operations push (insert a new element on the top of the stack) and pop (remove and return the element at the top of the stack.

A stack is an abstract data type that serves as a collection of elements, with two main principal operations:

  • Push, which adds an element to the collection, and
  • Pop, which removes the most recently added element that was not yet removed.

The order in which elements come off a stack gives rise to its alternative name, LIFO (last in, first out). Additionally, a peek operation may give access to the top without modifying the stack.[1] The name “stack” for this type of structure comes from the analogy to a set of physical items stacked on top of each other. This structure makes it easy to take an item off the top of the stack, while getting to an item deeper in the stack may require taking off multiple other items first.

Photo of a Stack of plates

Here is an example of a simple linked-list implementation of a stack, together with some test code:

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

struct elt {
    struct elt *next;
    int value;

 * We could make a struct for this,
 * but it would have only one component,
 * so this is quicker.
typedef struct elt *Stack;

#define STACK_EMPTY (0)

/* push a new value onto top of stack */
stackPush(Stack *s, int value)
    struct elt *e;

    e = malloc(sizeof(struct elt));

    e->value = value;
    e->next = *s;
    *s = e;

stackEmpty(const Stack *s)
    return (*s == 0);

stackPop(Stack *s)
    int ret;
    struct elt *e;


    ret = (*s)->value;

    /* patch out first element */
    e = *s;
    *s = e->next;


    return ret;

/* print contents of stack on a single line */
stackPrint(const Stack *s)
    struct elt *e;

    for(e = *s; e != 0; e = e->next) {
        printf("%d ", e->value);

main(int argc, char **argv)
    int i;
    Stack s;

    s = STACK_EMPTY;

    for(i = 0; i < 5; i++) {
        printf("push %d\n", i);
        stackPush(&s, i);

    while(!stackEmpty(&s)) {
        printf("pop gets %d\n", stackPop(&s));

    return 0;


Unlike most of our abstract data types, we do not include a struct representing the linked list itself. This is because the only thing we need to keep track of a linked list is the head pointer, and it feels a little silly to have a struct with just one component. But we might choose to do this if we wanted to make the linked list implementation opaque or allow for including more information later.

struct stack {
    struct elt *head;

Building a stack out of an array

When the elements of a stack are small, or when a maximum number of elements is known in advance, it often makes sense to build a stack from an array (with a variable storing the index of the top element) instead of a linked list. The reason is that pushes and pops only require updating the stack pointer instead of calling malloc or free to allocate space, and pre-allocating is almost always faster than allocating as needed. This is the strategy used to store the function call stack in almost all programs (the exception is in languages like Scheme, where the call stack is allocated on the heap because stack frames may outlive the function call that creates them).

Licenses and Attributions

Speak Your Mind