Push Using Linked List Node in DSA C#

Mental Model

Adding a new item at the start of a linked list means making the new item point to the current first item, then updating the start to this new item.

Analogy: Imagine a line of people holding hands. To add a new person at the front, the new person grabs the hand of the first person, then becomes the new front of the line.

head -> 1 -> 2 -> 3 -> null
newNode (value 0) ↑

Dry Run Walkthrough

Input: list: 1 -> 2 -> 3 -> null, push value 0

Goal: Add a new node with value 0 at the start of the list

Step 1: Create new node with value 0

head -> 1 -> 2 -> 3 -> null
newNode(0) ↑

Why: We need a new node to add to the list

Step 2: Set new node's next to current head (node 1)

newNode(0) -> 1 -> 2 -> 3 -> null
head -> 1 -> 2 -> 3 -> null

Why: New node must point to the old first node to keep the list connected

Step 3: Update head to new node

head -> 0 -> 1 -> 2 -> 3 -> null

Why: New node is now the first node in the list

Result:

head -> 0 -> 1 -> 2 -> 3 -> null

Annotated Code

DSA C#

using System;

public class Node
{
    public int data;
    public Node next;

    public Node(int data)
    {
        this.data = data;
        this.next = null;
    }
}

public class LinkedList
{
    public Node head;

    public void Push(int newData)
    {
        Node newNode = new Node(newData); // create new node
        newNode.next = head; // link new node to current head
        head = newNode; // update head to new node
    }

    public void PrintList()
    {
        Node temp = head;
        while (temp != null)
        {
            Console.Write(temp.data + " -> ");
            temp = temp.next;
        }
        Console.WriteLine("null");
    }
}

public class Program
{
    public static void Main()
    {
        LinkedList list = new LinkedList();
        list.head = new Node(1);
        list.head.next = new Node(2);
        list.head.next.next = new Node(3);

        list.Push(0); // push value 0 at front
        list.PrintList();
    }
}

Node newNode = new Node(newData); // create new node

create a new node with the given value

newNode.next = head; // link new node to current head

make new node point to the current first node

head = newNode; // update head to new node

update head pointer to new node, making it first

Output

0 -> 1 -> 2 -> 3 -> null

Complexity Analysis

Time: O(1) because we only change a few pointers without traversing the list

Space: O(1) because we create only one new node regardless of list size

vs Alternative: Compared to adding at the end which requires O(n) traversal, pushing at front is faster and simpler

Edge Cases

empty list (head is null)

new node becomes the head and points to null

DSA C#

newNode.next = head; // link new node to current head

single element list

new node points to the single existing node and becomes new head

DSA C#

head = newNode; // update head to new node

When to Use This Pattern

When you need to add an item quickly at the start of a list, use the push pattern to insert in O(1) time by updating head pointer.

Common Mistakes

Mistake: Forgetting to update the head pointer to the new node
Fix: Always assign head = newNode after linking newNode.next to old head

Mistake: Setting newNode.next to null instead of current head
Fix: Set newNode.next = head to keep the list connected

Summary

Adds a new node at the beginning of a linked list.

Use when you want to insert quickly at the front without traversing.

The new node points to the old head, then head updates to new node.

Practice

1. What does the push operation do in a linked list when using nodes?

easy

A. Adds a new node at the beginning of the list

B. Removes the last node from the list

C. Searches for a node with a specific value

D. Deletes the first node from the list

Solution

1. Step 1: Understand push operation in linked list

   The push operation inserts a new node at the start of the linked list.

2. Step 2: Effect of push on list structure

   The new node becomes the head, and its next pointer points to the old head.

3. Final Answer:

   Adds a new node at the beginning of the list -> Option A

4. Quick Check:

   Push means insert at head [OK]

Hint: Push always adds node at the start of the list [OK]

Common Mistakes:

• Confusing push with pop operation
• Thinking push adds at the end
• Assuming push deletes nodes

2. Which of the following is the correct syntax to create a new node and push it onto a linked list in C#?

easy

A. Node newNode = new Node(); head = newNode.next; newNode.data = data;

B. Node newNode = new Node(data); newNode.next = head; head = newNode;

C. head = new Node(data); head.next = null;

D. Node newNode = new Node(data); head = newNode.next; newNode = head;

Solution

1. Step 1: Create new node with data

   Use new Node(data) to create a node with the given data.

2. Step 2: Link new node to current head and update head

   Set newNode.next = head and then head = newNode to push at front.

3. Final Answer:

   Node newNode = new Node(data); newNode.next = head; head = newNode; -> Option B

4. Quick Check:

   New node points to old head, then head updated [OK]

Hint: New node next points to head, then head updated [OK]

Common Mistakes:

• Assigning head before setting newNode.next
• Not initializing new node with data
• Swapping head and newNode incorrectly

3. What will be the output linked list after executing this code?

Node head = null;
head = new Node(10);
head.next = new Node(20);
Node newNode = new Node(5);
newNode.next = head;
head = newNode;

Print the list from head to end.

medium

A. 10 -> 20 -> 5 -> null

B. 5 -> 20 -> 10 -> null

C. 20 -> 10 -> 5 -> null

D. 5 -> 10 -> 20 -> null

Solution

1. Step 1: Initial list creation

   Head points to node 10, which points to node 20, then null.

2. Step 2: Push new node with value 5

   New node 5 points to old head (10), then head updated to new node 5.

3. Final Answer:

   5 -> 10 -> 20 -> null -> Option D

4. Quick Check:

   New node added at front [OK]

Hint: New node points to old head, becomes new head [OK]

Common Mistakes:

• Appending new node at end instead of front
• Not updating head to new node
• Confusing node order after push

4. Identify the error in this push method for a singly linked list:

public void Push(int data) {
    Node newNode = new Node(data);
    newNode.next = null;
    head = newNode;
}

medium

A. newNode.next should point to current head before updating head

B. Node constructor is missing data parameter

C. head should be set to null before assigning newNode

D. No error, code is correct

Solution

1. Step 1: Analyze newNode.next assignment

   Setting newNode.next = null disconnects new node from existing list.

2. Step 2: Correct linking for push operation

   New node's next should point to current head to keep list intact before updating head.

3. Final Answer:

   newNode.next should point to current head before updating head -> Option A

4. Quick Check:

   Link new node to old head before head update [OK]

Hint: Link new node to old head before changing head [OK]

Common Mistakes:

• Setting newNode.next to null breaks list
• Not updating head after push
• Confusing order of assignments

5. Given a linked list with nodes 30 -> 20 -> 10 -> null, you want to push nodes 40 and 50 in that order using the push method. What will be the final list?

hard

A. 30 -> 20 -> 10 -> 50 -> 40 -> null

B. 40 -> 50 -> 30 -> 20 -> 10 -> null

C. 50 -> 40 -> 30 -> 20 -> 10 -> null

D. 30 -> 20 -> 10 -> 40 -> 50 -> null

Solution

1. Step 1: Initial list and first push

   Start with 30 -> 20 -> 10 -> null. Push 40: new head is 40, list is 40 -> 30 -> 20 -> 10 -> null.

2. Step 2: Second push with 50

   Push 50: new head is 50, list becomes 50 -> 40 -> 30 -> 20 -> 10 -> null.

3. Final Answer:

   50 -> 40 -> 30 -> 20 -> 10 -> null -> Option C

4. Quick Check:

   Push adds nodes at front in reverse order [OK]

Hint: Last pushed node becomes new head [OK]

Common Mistakes:

• Assuming push adds at end
• Mixing order of pushed nodes
• Not updating head after each push