Insert at Beginning Head Insert in DSA C# - Build from Scratch

Insert at Beginning Head Insert

📖 Scenario: You are managing a simple list of tasks to do today. You want to add new tasks at the very start of your list so that the newest tasks get done first.

🎯 Goal: Build a singly linked list and insert new nodes at the beginning (head) of the list. Then print the list to see the order of tasks.

📋 What You'll Learn

Create a singly linked list node class called Node with string data and Node next fields

Create a linked list class called LinkedList with a Node head field

Write a method InsertAtBeginning(string data) to add a new node at the start of the list

Write a method PrintList() to print all nodes in order separated by ' -> ' and ending with 'null'

💡 Why This Matters

🌍 Real World

Linked lists are used in many applications where dynamic data needs to be stored and updated efficiently, such as task scheduling and undo functionality.

💼 Career

Understanding linked lists and how to insert nodes at the beginning is fundamental for software developers working with data structures and memory management.

1

Create Node and LinkedList classes

Create a class called Node with a public string data field and a public Node next field. Then create a class called LinkedList with a public Node head field initialized to null.

DSA C#

// Your code here to create Node and LinkedList classes

Hint

Think of Node as a box holding a task and a pointer to the next box. LinkedList keeps track of the first box.

2

Add InsertAtBeginning method

Inside the LinkedList class, add a public method called InsertAtBeginning that takes a string data parameter. This method should create a new Node with the given data, set its next to the current head, and then update head to this new node.

DSA C#

public class Node
{
    public string data;
    public Node next;

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

public class LinkedList
{
    public Node head = null;

    // Your code here to add InsertAtBeginning method
}

Hint

Remember to link the new node to the old head before updating the head pointer.

3

Add PrintList method

Inside the LinkedList class, add a public method called PrintList that prints all node data in order separated by " -> " and ends with "null". Use a Node current variable to traverse from head until null.

DSA C#

public class Node
{
    public string data;
    public Node next;

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

public class LinkedList
{
    public Node head = null;

    public void InsertAtBeginning(string data)
    {
        Node newNode = new Node(data);
        newNode.next = head;
        head = newNode;
    }

    // Your code here to add PrintList method
}

Hint

Use a loop to visit each node and print its data, then print 'null' at the end.

4

Insert tasks and print the list

In the Main method, create a LinkedList object called tasks. Use InsertAtBeginning to add these tasks in order: "Wash dishes", "Do laundry", "Buy groceries". Then call PrintList() on tasks to display the list.

DSA C#

public class Node
{
    public string data;
    public Node next;

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

public class LinkedList
{
    public Node head = null;

    public void InsertAtBeginning(string data)
    {
        Node newNode = new Node(data);
        newNode.next = head;
        head = newNode;
    }

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

class Program
{
    static void Main()
    {
        // Your code here to create LinkedList, insert tasks, and print
    }
}

Hint

Remember that inserting at the beginning reverses the order of insertion.

Practice

1. What does the "Insert at Beginning" operation do in a singly linked list?

easy

A. Deletes the last node of the list

B. Adds a new node at the start of the list

C. Deletes the first node of the list

D. Adds a new node at the end of the list

Solution

1. Step 1: Understand the operation

   Inserting at the beginning means placing a new node before the current first node.

2. Step 2: Effect on the list

   The new node becomes the head, pushing existing nodes after it.

3. Final Answer:

   Adds a new node at the start of the list -> Option B

4. Quick Check:

   Insert at beginning = Add new head [OK]

Hint: New node becomes head, old head moves next [OK]

Common Mistakes:

• Confusing insert at beginning with insert at end
• Thinking it deletes nodes
• Assuming it changes the tail node

2. Which of the following is the correct syntax to insert a new node at the beginning of a singly linked list in C#?

easy

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

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

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

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

Solution

1. Step 1: Create new node and link

   Create a new node and set its next pointer to current head.

2. Step 2: Update head pointer

   Assign head to the new node to make it the first node.

3. Final Answer:

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

4. Quick Check:

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

Hint: New node next = head; head = new node [OK]

Common Mistakes:

• Not updating head after creating new node
• Assigning head before setting newNode.next
• Creating multiple new nodes unnecessarily

3. What will be the output of the following code snippet?

class Node {
  public int data;
  public Node next;
  public Node(int d) { data = d; next = null; }
}

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

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

medium

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

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

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

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

Solution

1. Step 1: Initial list creation

   Head points to 10, which points to 20 (10 -> 20 -> null).

2. Step 2: Insert new node at beginning

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

3. Step 3: Traverse and print list

   Traversal prints 5 -> 10 -> 20 -> null.

4. Final Answer:

   5 -> 10 -> 20 -> null -> Option A

5. Quick Check:

   New head 5, followed by 10 and 20 [OK]

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

Common Mistakes:

• Confusing order of nodes after insertion
• Not updating head pointer
• Printing nodes before insertion

4. Identify the error in the following code that tries to insert a node at the beginning of a singly linked list:

Node newNode = new Node(15);
newNode.next = newNode;
head = newNode;

medium

A. head should be assigned before setting newNode.next

B. Node constructor is missing data parameter

C. newNode.next should point to head, not newNode

D. No error, code is correct

Solution

1. Step 1: Analyze newNode.next assignment

   newNode.next points to itself, creating a cycle instead of linking to the list.

2. Step 2: Correct pointer assignment

   newNode.next should point to current head to insert at beginning properly.

3. Final Answer:

   newNode.next should point to head, not newNode -> Option C

4. Quick Check:

   Link new node to old head, not itself [OK]

Hint: newNode.next = head, not newNode [OK]

Common Mistakes:

• Setting next pointer to newNode itself
• Not updating head after insertion
• Confusing order of assignments

5. You have a singly linked list with nodes containing values [30, 40, 50]. You want to insert nodes with values [10, 20] at the beginning in that order so the final list is [10, 20, 30, 40, 50]. Which sequence of insertions achieves this?

hard

A. Insert 20 at beginning, then insert 10 at beginning

B. Insert 10 at beginning, then insert 20 at beginning

C. Insert 10 at end, then insert 20 at beginning

D. Insert 20 at end, then insert 10 at beginning

Solution

1. Step 1: Understand insertion order effect

   Each insert at beginning places new node before current head.

2. Step 2: Insert 10 first, then 20

   Inserting 10 first results in list [10, 30, 40, 50]. Then inserting 20 at beginning results in [20, 10, 30, 40, 50].

3. Step 3: Reverse the order to get desired list

   To get [10, 20, 30, 40, 50], insert 20 first, then 10.

4. Final Answer:

   Insert 20 at beginning, then insert 10 at beginning -> Option A

5. Quick Check:

   Last inserted node becomes new head [OK]

Hint: Insert last value first to keep order at head [OK]

Common Mistakes:

• Inserting in given order causes reversed nodes
• Confusing insert at beginning with insert at end
• Not updating head after each insertion