Push Using Linked List Node in DSA C# - Build from Scratch

Push Using Linked List Node

📖 Scenario: You are building a simple stack using a linked list. A stack is like a stack of plates where you add new plates on top. Here, each plate is a node in the linked list.

🎯 Goal: Create a linked list node class and write code to add (push) a new node at the start of the linked list. Then print the linked list to see the order of nodes.

📋 What You'll Learn

Create a Node class with an integer data and a next pointer.

Create a variable head to point to the start of the linked list.

Create a method Push that takes an integer and adds a new node at the start.

Print the linked list nodes from head to the end.

💡 Why This Matters

🌍 Real World

Linked lists are used in many software systems to manage data dynamically, like undo features, navigation history, and memory management.

💼 Career

Understanding linked lists and stack operations is essential for software developers, especially in roles involving system design, algorithms, and data structure optimization.

1

Create the Node class and head variable

Create a class called Node with two public members: an integer data and a Node reference called next. Then create a variable called head of type Node and set it to null.

DSA C#

// Define the Node class and create head variable
// Your code here

Hint

Think of Node as a box holding a number and a pointer to the next box.

2

Create the Push method

Create a method called Push that takes an integer newData. Inside it, create a new Node with newData. Set the new node's next to the current head. Then update head to this new node.

DSA C#

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

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

Node head = null;

// Create Push method below
// Your code here

Hint

Remember, pushing means adding a new node at the start and updating head.

3

Push three nodes onto the list

Call the Push method three times to add nodes with values 10, 20, and 30 in that order.

DSA C#

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

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

Node head = null;

void Push(int newData)
{
    Node newNode = new Node(newData);
    newNode.next = head;
    head = newNode;
}

// Push 10, 20, and 30 onto the list
// Your code here

Hint

Call Push three times with the exact values.

4

Print the linked list

Write a while loop to print the data of each node starting from head. Print each value followed by " -> ". After the loop, print "null".

DSA C#

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

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

Node head = null;

void Push(int newData)
{
    Node newNode = new Node(newData);
    newNode.next = head;
    head = newNode;
}

Push(10);
Push(20);
Push(30);

// Print the linked list
// Your code here

Hint

Use a temporary variable to walk through the list and print each node's data.

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