Pop Operation on Stack in DSA C# - Time & Space Complexity

Time Complexity: Pop Operation on Stack

O(1)

Understanding Time Complexity

We want to understand how long it takes to remove an item from a stack.

Specifically, how the time changes as the stack grows bigger.

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

public class Stack
{
    private int[] items;
    private int top = -1;

    public int Pop()
    {
        if (top == -1) throw new InvalidOperationException("Stack is empty");
        return items[top--];
    }
}
    

This code removes the top item from the stack and returns it.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Accessing the top element and decreasing the top index by one.
• How many times: This happens once per pop call, no loops or recursion involved.

How Execution Grows With Input

Removing the top item takes the same steps no matter how big the stack is.

Input Size (n)	Approx. Operations
10	1
100	1
1000	1

Pattern observation: The time stays the same even if the stack grows larger.

Final Time Complexity

Time Complexity: O(1)

This means popping an item takes a fixed amount of time regardless of stack size.

Common Mistake

[X] Wrong: "Pop takes longer if the stack has more items because it has to check all elements."

[OK] Correct: Pop only removes the top item directly without checking others, so time does not grow with stack size.

Interview Connect

Knowing that pop is a constant time operation helps you explain why stacks are efficient for last-in-first-out tasks.

Self-Check

"What if the stack was implemented using a linked list instead of an array? How would the time complexity of pop change?"

Practice

1. What does the Pop() operation do in a stack?

easy

A. Adds an element to the bottom of the stack

B. Clears all elements from the stack

C. Returns the bottom element without removing it

D. Removes and returns the top element of the stack

Solution

1. Step 1: Understand the stack behavior

   A stack follows Last In First Out (LIFO) principle, so the last added element is on top.

2. Step 2: Define the Pop operation

   Pop removes and returns the top element, which is the last inserted item.

3. Final Answer:

   Removes and returns the top element of the stack -> Option D

4. Quick Check:

   Pop = remove top element [OK]

Hint: Pop always removes the last added item [OK]

Common Mistakes:

• Thinking Pop adds elements
• Confusing Pop with Peek
• Assuming Pop removes bottom element

2. Which of the following is the correct syntax to pop an element from a stack named myStack in C#?

easy

A. myStack.Pop();

B. myStack.pop();

C. Pop(myStack);

D. myStack.PopElement();

Solution

1. Step 1: Recall C# method naming conventions

   In C#, method names are case-sensitive and usually PascalCase.

2. Step 2: Identify the correct method call

   The Stack class has a method named Pop() with uppercase P, called on the stack instance.

3. Final Answer:

   myStack.Pop(); -> Option A

4. Quick Check:

   Correct method name and syntax = myStack.Pop(); [OK]

Hint: C# methods are case-sensitive and PascalCase [OK]

Common Mistakes:

• Using lowercase 'pop()' instead of 'Pop()'
• Trying to call Pop as a standalone function
• Using incorrect method names like PopElement

3. What will be the output of the following C# code?

Stack<int> stack = new Stack<int>();
stack.Push(10);
stack.Push(20);
stack.Push(30);
int popped = stack.Pop();
Console.WriteLine(popped);
Console.WriteLine(string.Join(", ", stack));

medium

A. 10
20, 30

B. 30
20, 10

C. 20
10, 30

D. 30
10, 20

Solution

1. Step 1: Trace the Push operations

   Elements pushed in order: 10 (bottom), 20, 30 (top).

2. Step 2: Pop removes top element

   Pop removes 30, so popped = 30. Remaining stack: 20 (top), 10 (bottom).

3. Step 3: Print statements

   First line prints popped = 30. Second line prints stack elements from top to bottom: 20, 10.

4. Final Answer:

   30 20, 10 -> Option B

5. Quick Check:

   Pop returns top (30), stack now 20, 10 [OK]

Hint: Pop returns last pushed; stack order reverses on print [OK]

Common Mistakes:

• Confusing order of elements after pop
• Printing stack in wrong order
• Assuming Pop returns bottom element

4. Identify the error in the following C# code snippet that uses a stack:

Stack<string> stack = new Stack<string>();
stack.Push("apple");
stack.Push("banana");
string fruit = stack.Pop();
Console.WriteLine(fruit);
Console.WriteLine(stack.Pop());
Console.WriteLine(stack.Pop());

medium

A. Pop method is called incorrectly

B. No error, code runs fine

C. Third Pop causes InvalidOperationException (stack empty)

D. Stack should be initialized with capacity

Solution

1. Step 1: Count Push and Pop calls

   Two Push calls add "apple" and "banana". Three Pop calls remove elements.

2. Step 2: Analyze stack state after Pops

   First Pop removes "banana", second Pop removes "apple", third Pop tries to remove from empty stack causing error.

3. Final Answer:

   Third Pop causes InvalidOperationException (stack empty) -> Option C

4. Quick Check:

   Pop on empty stack throws exception [OK]

Hint: Pop more times than Push causes error [OK]

Common Mistakes:

• Ignoring stack empty error
• Assuming Pop returns null if empty
• Thinking stack needs capacity on init

5. Given a stack with elements [5, 10, 15, 20] (5 at bottom, 20 at top), what will be the stack content after performing two Pop() operations followed by one Push(25) operation?

hard

A. [5, 10, 25]

B. [5, 10, 15, 25]

C. [10, 15, 25]

D. [5, 15, 25]

Solution

1. Step 1: Understand initial stack order

   Stack bottom to top: 5, 10, 15, 20.

2. Step 2: Perform two Pop operations

   First Pop removes 20, second Pop removes 15. Remaining stack: 5, 10.

3. Step 3: Perform Push(25)

   Push adds 25 on top. Final stack: 5, 10, 25.

4. Final Answer:

   [5, 10, 25] -> Option A

5. Quick Check:

   Pop twice removes top two; Push adds new top [OK]

Hint: Pop removes top; Push adds new top [OK]

Common Mistakes:

• Removing wrong elements on Pop
• Adding Push element at bottom
• Confusing stack order after operations