Linked Structures

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.cpp 
#include <iostream>
#include <sstream>
#include <string>
using namespace std;

struct Node {
    int value;
    Node* next;
    Node(int v, Node* n = nullptr) : value(v), next(n) {}
};

string render(Node* head) {
    ostringstream out;
    Node* cursor = head;
    while (cursor != nullptr) {
        if (cursor != head) out << " -> ";
        out << cursor->value;
        cursor = cursor->next;
    }
    out << " -> null";
    return out.str();
}

int main() {
    Node* head = new Node(20, new Node(30));
    Node* new_head = new Node(10);
    new_head->next = head;
    head = new_head;
    cout << render(head) << endl;
}

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).

Original chain before inserting 10 at the head.headnode(20)node(30)null

Step 2 - New node links to old head

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

node(10) is allocated and points at the old head node(20).headnode(10)newnode(20)old headnode(30)null

Step 3 - Head moves to the new node

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

After insertion, head points at node(10).headnode(10)node(20)node(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.