Insert at Head

Algorithm

The replay labels nodes by value, such as node(20), and never exposes object identity or memory addresses. This C# DSA implementation uses the same small chain as the rest of the DSA track.

old head The previous first node becomes the second node.

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

Visual walkthrough

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.

Basic Implementation

                            basic.cs
                        

                            using System;
using System.Text;

class Node {
    public int Value;
    public Node? Next;
    public Node(int value, Node? next = null) {
        Value = value;
        Next = next;
    }
}

class Program {
    static string Render(Node? head) {
        var outText = new StringBuilder();
        var cursor = head;
        while (cursor != null) {
            if (outText.Length > 0) outText.Append(" -> ");
            outText.Append(cursor.Value);
            cursor = cursor.Next;
        }
        return outText.Append(" -> null").ToString();
    }
    static void Main() {
        Node head = new Node(20, new Node(30));
        Node newHead = new Node(10);
        newHead.Next = head;
        head = newHead;
        Console.WriteLine(Render(head));
    }
}

                        

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.