Delete Node at Beginning in DSA C#

Mental Model

Removing the first item means moving the start pointer to the next item, skipping the old first.

Analogy: Imagine a line of people holding hands. To remove the first person, the second person becomes the new front of the line.

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

Dry Run Walkthrough

Input: list: 1 -> 2 -> 3 -> null, delete node at beginning

Goal: Remove the first node and update the list to start from the second node

Step 1: Identify the current head node (1) to remove

head -> [1] -> 2 -> 3 -> null

Why: We must know which node to remove first

Step 2: Move head pointer to the next node (2)

head -> [2] -> 3 -> null

Why: This skips the first node, effectively removing it from the list

Step 3: Old first node (1) is no longer referenced and can be cleaned up

head -> 2 -> 3 -> null

Why: The list now starts at the second node, completing the deletion

Result:

head -> 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 LinkedList()
    {
        head = null;
    }

    public void InsertAtEnd(int data)
    {
        Node newNode = new Node(data);
        if (head == null)
        {
            head = newNode;
            return;
        }
        Node curr = head;
        while (curr.next != null)
        {
            curr = curr.next;
        }
        curr.next = newNode;
    }

    public void DeleteAtBeginning()
    {
        if (head == null) return; // empty list, nothing to delete
        head = head.next; // move head to next node, removing first
    }

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

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

        list.DeleteAtBeginning();
        list.PrintList();
    }
}

if (head == null) return; // empty list, nothing to delete

check if list is empty to avoid errors

head = head.next; // move head to next node, removing first

advance head pointer to remove first node

Output

2 -> 3 -> null

Complexity Analysis

Time: O(1) because we only change the head pointer without traversing the list

Space: O(1) because no extra space is used during deletion

vs Alternative: Compared to deleting a node at the end which requires traversal O(n), deleting at beginning is faster and simpler

Edge Cases

empty list

no deletion occurs, list remains empty

DSA C#

if (head == null) return; // empty list, nothing to delete

single node list

head moves to null, list becomes empty

DSA C#

head = head.next; // move head to next node, removing first

When to Use This Pattern

When asked to remove the first element of a linked list quickly, use the delete at beginning pattern because it only needs to move the head pointer.

Common Mistakes

Mistake: Trying to traverse the list to delete the first node
Fix: Directly move the head pointer to the next node without traversal

Mistake: Not checking if the list is empty before deletion
Fix: Add a check if head is null before deleting

Summary

Deletes the first node by moving the head pointer to the next node.

Use when you need to remove the front element of a singly linked list efficiently.

The key is that deleting at the beginning is just changing the head pointer.

Practice

1. What happens when you delete the first node in a singly linked list?

easy

A. The last node is deleted instead of the first

B. Nothing happens because the first node cannot be deleted

C. The entire list is deleted

D. The head pointer moves to the second node, removing the first node from the list

Solution

1. Step 1: Understand the head pointer role

   The head pointer points to the first node in the list.

2. Step 2: Update head to next node

   Deleting the first node means moving the head pointer to the second node, effectively removing the first node.

3. Final Answer:

   The head pointer moves to the second node, removing the first node from the list -> Option D

4. Quick Check:

   Delete first node = move head to next [OK]

Hint: Delete first node by moving head to next node [OK]

Common Mistakes:

• Trying to delete the last node instead
• Not updating the head pointer
• Deleting the entire list accidentally

2. Which of the following is the correct syntax to delete the first node in a singly linked list in C#?

easy

A. head = null.next;

B. head.next = head;

C. head = head.next;

D. head.next = null;

Solution

1. Step 1: Identify the head pointer update

   To delete the first node, assign head to head.next to move the head pointer forward.

2. Step 2: Check syntax correctness

   head = head.next; correctly updates the head pointer to the second node.

3. Final Answer:

   head = head.next; -> Option C

4. Quick Check:

   Correct syntax to delete first node = head = head.next; [OK]

Hint: Assign head to head.next to delete first node [OK]

Common Mistakes:

• Reversing the assignment order
• Using null.next which is invalid
• Setting head.next to null instead of head

3. Consider the following code snippet for deleting the first node in a linked list:

Node head = new Node(1);
head.next = new Node(2);
head.next.next = new Node(3);
head = head.next;

What is the state of the list after deletion?

medium

A. 2 -> 3 -> null

B. null

C. 3 -> null

D. 1 -> 2 -> 3 -> null

Solution

1. Step 1: Initial list creation

   The list starts as 1 -> 2 -> 3 -> null with head at node 1.

2. Step 2: Delete first node by moving head

   head = head.next moves head to node 2, so the list becomes 2 -> 3 -> null.

3. Final Answer:

   2 -> 3 -> null -> Option A

4. Quick Check:

   After deletion, list starts at second node [OK]

Hint: After deletion, list starts from second node [OK]

Common Mistakes:

• Forgetting to update head pointer
• Assuming first node still exists
• Confusing node values after deletion

4. The following code attempts to delete the first node of a linked list but causes a runtime error:

Node head = null;
head = head.next;

What is the error and how to fix it?

medium

A. SyntaxError; fix by adding semicolon

B. NullReferenceException; fix by checking if head is not null before deleting

C. IndexOutOfRangeException; fix by resizing list

D. No error; code works fine

Solution

1. Step 1: Identify cause of error

   head is null, so accessing head.next causes NullReferenceException.

2. Step 2: Fix by adding null check

   Check if head != null before assigning head = head.next to avoid error.

3. Final Answer:

   NullReferenceException; fix by checking if head is not null before deleting -> Option B

4. Quick Check:

   Null head causes error; check before delete [OK]

Hint: Always check head != null before deleting first node [OK]

Common Mistakes:

• Ignoring null checks causing runtime errors
• Assuming list always has nodes
• Confusing syntax errors with runtime errors

5. You have a singly linked list with nodes: 5 -> 10 -> 15 -> 20 -> null. You delete the first node twice using head = head.next; two times. What is the resulting list?

hard

A. 15 -> 20 -> null

B. 10 -> 15 -> 20 -> null

C. 20 -> null

D. null

Solution

1. Step 1: Initial list and first deletion

   List starts as 5 -> 10 -> 15 -> 20 -> null. After first deletion, head moves to 10, list is 10 -> 15 -> 20 -> null.

2. Step 2: Second deletion moves head again

   After second deletion, head moves to 15, list is 15 -> 20 -> null.

3. Final Answer:

   15 -> 20 -> null -> Option A

4. Quick Check:

   Two deletions remove first two nodes [OK]

Hint: Each deletion moves head to next node [OK]

Common Mistakes:

• Deleting only once instead of twice
• Confusing node values after multiple deletions
• Assuming list becomes empty too early