Insert at Head

Insert a new first node by pointing it at the old head and then moving the head pointer.

Algorithm

Basic Implementation

basic.c

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

typedef struct Node {
    int value;
    struct Node* next;
} Node;

Node* node(int value, Node* next) {
    Node* n = malloc(sizeof(Node));
    n->value = value;
    n->next = next;
    return n;
}

void print_chain(Node* head) {
    Node* cursor = head;
    while (cursor != NULL) {
        printf("%d -> ", cursor->value);
        cursor = cursor->next;
    }
    printf("null\n");
}

int main(void) {
    Node* head = node(20, node(30, NULL));
    Node* new_head = node(10, NULL);
    new_head->next = head;
    head = new_head;
    print_chain(head);
    return 0;
}

Head insertion changes only two references: the new node points at the old head, then head moves to the new node.

Step 1 - Old first node

Before insertion, head points at node(20).

Step 2 - New node links to old head

Set new.next to the old first node before moving head.

Step 3 - Head moves to the new node

The final chain has 10 first: 10 -> 20 -> 30 -> null.

Complexity

Time: O(1)
Space: O(1)

Implementation notes

Keep the explicit node and pointer/reference operations; array shortcuts hide the linked-list state this lesson is meant to replay.
The final output prints the chain in a deterministic a -> b -> null form for cross-language comparison.

old head The previous first node becomes the second node.

constant-time insert Only the new node and head pointer change.