Pop Using Linked List Node in DSA C# - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output after popping the head node?

Consider a singly linked list with nodes 10 -> 20 -> 30 -> null. After popping the head node, what will be the new list?

DSA C#

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

class LinkedList {
    public Node head;
    public void Push(int data) {
        Node newNode = new Node(data);
        newNode.next = head;
        head = newNode;
    }
    public int Pop() {
        if (head == null) throw new InvalidOperationException("List is empty");
        int val = head.data;
        head = head.next;
        return val;
    }
    public override string ToString() {
        Node current = head;
        string result = "";
        while (current != null) {
            result += current.data + " -> ";
            current = current.next;
        }
        return result + "null";
    }
}

LinkedList list = new LinkedList();
list.Push(30);
list.Push(20);
list.Push(10);
list.Pop();
Console.WriteLine(list.ToString());

A 10 -> 20 -> 30 -> null

B 20 -> 30 -> null

C 30 -> 20 -> null

D null

💡 Hint

Popping removes the first node (head) from the list.

Initially, nodes are pushed in order 30, 20, 10, so list is 10 -> 20 -> 30 -> null. Popping removes 10, so new head is 20.

❓ Predict Output

intermediate

What is the output after two pops on the linked list?

Given a linked list with nodes 5 -> 15 -> 25 -> null, what is the list after popping twice?

DSA C#

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

class LinkedList {
    public Node head;
    public void Push(int data) {
        Node newNode = new Node(data);
        newNode.next = head;
        head = newNode;
    }
    public int Pop() {
        if (head == null) throw new InvalidOperationException("List is empty");
        int val = head.data;
        head = head.next;
        return val;
    }
    public override string ToString() {
        Node current = head;
        string result = "";
        while (current != null) {
            result += current.data + " -> ";
            current = current.next;
        }
        return result + "null";
    }
}

LinkedList list = new LinkedList();
list.Push(25);
list.Push(15);
list.Push(5);
list.Pop();
list.Pop();
Console.WriteLine(list.ToString());

A 5 -> 15 -> 25 -> null

B 15 -> 25 -> null

C 25 -> null

D null

💡 Hint

Each pop removes the head node.

Pushing 25, 15, 5 results in list 5 -> 15 -> 25 -> null. Two pops remove 5 and then 15, leaving 25 -> null.

🔧 Debug

advanced

What error occurs when popping from an empty linked list?

Consider the pop method below. What error will be raised if pop is called on an empty list?

DSA C#

public int Pop() {
    if (head == null) throw new InvalidOperationException("List is empty");
    int val = head.data;
    head = head.next;
    return val;
}

LinkedList list = new LinkedList();
list.Pop();

A InvalidOperationException

B NullReferenceException

C IndexOutOfRangeException

D No error, returns 0

💡 Hint

Check the condition when head is null.

The code explicitly throws InvalidOperationException when head is null, so that error occurs.

❓ Predict Output

advanced

What is the output after popping all nodes one by one?

Given a linked list with nodes 1 -> 2 -> 3 -> null, what is printed after popping all nodes and printing each popped value?

DSA C#

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

class LinkedList {
    public Node head;
    public void Push(int data) {
        Node newNode = new Node(data);
        newNode.next = head;
        head = newNode;
    }
    public int Pop() {
        if (head == null) throw new InvalidOperationException("List is empty");
        int val = head.data;
        head = head.next;
        return val;
    }
}

LinkedList list = new LinkedList();
list.Push(3);
list.Push(2);
list.Push(1);
while (true) {
    try {
        Console.Write(list.Pop() + " ");
    } catch (InvalidOperationException) {
        break;
    }
}

A 3 2 1

B 1 3 2

C 3 1 2

D 1 2 3

💡 Hint

Pop removes from the head, which is the last pushed node.

Nodes pushed: 3, then 2, then 1. List is 1 -> 2 -> 3. Popping removes 1, then 2, then 3, printing in that order.

🧠 Conceptual

expert

What is the time complexity of popping the head node in a singly linked list?

Consider a singly linked list with n nodes. What is the time complexity of the pop operation that removes the head node?

A O(1) constant time

B O(n^2) quadratic time

C O(log n) logarithmic time

D O(n) linear time

💡 Hint

Popping the head node only changes a pointer.

Removing the head node requires updating the head pointer only, which is a constant time operation.

Practice

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

easy

A. Searches for a node with a specific value

B. Adds a new node at the end of the linked list

C. Counts the total number of nodes in the linked list

D. Removes and returns the first node from the linked list

Solution

1. Step 1: Understand the pop operation

   The pop operation removes an element from a data structure. In a linked list, it usually removes the first node (head).

2. Step 2: Identify the effect on the linked list

   Removing the first node means the head pointer moves to the next node, and the removed node is returned.

3. Final Answer:

   Removes and returns the first node from the linked list -> Option D

4. Quick Check:

   Pop = Remove first node [OK]

Hint: Pop removes the first node in a linked list [OK]

Common Mistakes:

• Confusing pop with adding nodes
• Thinking pop removes the last node
• Assuming pop counts nodes

2. Which of the following is the correct syntax to pop a node from the head of a singly linked list in C#?

easy

A. head = null; return head;

B. head = head.next; return head;

C. Node temp = head; head = head.next; return temp;

D. Node temp = head.next; head = temp; return head;

Solution

1. Step 1: Save the current head node

   We store the current head in a temporary variable to return it later.

2. Step 2: Move head to the next node

   Update the head pointer to the next node in the list.

3. Step 3: Return the removed node

   Return the saved node which was the original head.

4. Final Answer:

   Node temp = head; head = head.next; return temp; -> Option C

5. Quick Check:

   Save head, move head next, return saved [OK]

Hint: Save head, move head to next, return saved node [OK]

Common Mistakes:

• Returning the new head instead of removed node
• Not saving the original head before moving
• Setting head to null incorrectly

3. Consider the following C# code for popping a node from a linked list:

Node head = new Node(10);
head.next = new Node(20);
head.next.next = new Node(30);

Node popped = Pop(ref head);
Console.WriteLine(popped.data);

What will be printed?

Assume Pop removes the first node and updates head.

medium

A. 10

B. 20

C. 30

D. NullReferenceException

Solution

1. Step 1: Understand initial linked list

   The list has nodes 10 -> 20 -> 30. Head points to node with data 10.

2. Step 2: Pop removes the first node

   Pop removes node 10 and updates head to node 20.

3. Step 3: Output the popped node's data

   The popped node's data is 10, so Console.WriteLine prints 10.

4. Final Answer:

   10 -> Option A

5. Quick Check:

   First node data popped = 10 [OK]

Hint: Pop returns first node's data before head moves [OK]

Common Mistakes:

• Printing head data after pop instead of popped node
• Confusing node values order
• Assuming pop returns null

4. The following C# method is intended to pop the first node from a linked list:

Node Pop(Node head) {
    Node temp = head;
    head = head.next;
    return temp;
}

What is the main problem with this code?

medium

A. It does not update the original head outside the method

B. It returns the wrong node

C. It causes a null pointer exception always

D. It deletes the entire linked list

Solution

1. Step 1: Analyze parameter passing

   The method receives head by value, so changes to head inside do not affect the caller's head.

2. Step 2: Understand effect on original list

   Since head is not updated outside, the original list's head remains unchanged, so pop does not remove the node effectively.

3. Final Answer:

   It does not update the original head outside the method -> Option A

4. Quick Check:

   Head passed by value, original not updated [OK]

Hint: Use ref to update head outside method [OK]

Common Mistakes:

• Assuming head changes inside method affect caller
• Thinking it returns wrong node
• Believing it causes runtime error

5. You have a singly linked list with nodes: 5 -> 15 -> 25 -> null.
You want to pop two nodes using a method that updates the head by reference.
After popping twice, what is the state of the linked list?

hard

A. 15 -> 25 -> null

B. 25 -> null

C. 5 -> 15 -> 25 -> null

D. null

Solution

1. Step 1: Initial linked list nodes

   The list starts as 5 -> 15 -> 25 -> null, head points to node with 5.

2. Step 2: Pop first node

   Pop removes node 5, head moves to node 15, list becomes 15 -> 25 -> null.

3. Step 3: Pop second node

   Pop removes node 15, head moves to node 25, list becomes 25 -> null.

4. Final Answer:

   25 -> null -> Option B

5. Quick Check:

   Two pops remove first two nodes [OK]

Hint: Each pop removes head, so two pops leave third node [OK]

Common Mistakes:

• Not updating head after pop
• Assuming popped nodes remain in list
• Confusing node order after pops