Stack Concept and LIFO Principle in DSA C# - Time & Space Complexity

Time Complexity: Stack Concept and LIFO Principle

O(1)

Understanding Time Complexity

We want to understand how fast stack operations run as the stack grows.

How does the time to add or remove items change when the stack gets bigger?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

public class SimpleStack
{
    private List<int> items = new List<int>();

    public void Push(int item)
    {
        items.Add(item); // Add item to the top
    }

    public int Pop()
    {
        int top = items[items.Count - 1];
        items.RemoveAt(items.Count - 1); // Remove top item
        return top;
    }
}
    

This code adds (push) and removes (pop) items from the end of a list to behave like a stack.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Adding or removing one item at the end of the list.
• How many times: Each push or pop does this once, no loops inside these methods.

How Execution Grows With Input

Each push or pop does a fixed amount of work regardless of stack size.

Input Size (n)	Approx. Operations
10	1 operation per push or pop
100	1 operation per push or pop
1000	1 operation per push or pop

Pattern observation: The time stays the same no matter how many items are in the stack.

Final Time Complexity

Time Complexity: O(1)

This means each push or pop takes the same short time no matter how big the stack is.

Common Mistake

[X] Wrong: "Removing an item from the stack takes longer if the stack is bigger."

[OK] Correct: Because we only remove or add at the end, the operation does not depend on stack size.

Interview Connect

Knowing that stack operations run in constant time shows you understand efficient data handling.

Self-Check

"What if we used a linked list instead of a list for the stack? How would the time complexity change?"

Practice

1. What does the LIFO principle mean in the context of a stack?

easy

A. Last In, First Out - the first element added is the first to be removed

B. First In, First Out - the first element added is the first to be removed

C. Last In, First Out - the last element added is the first to be removed

D. First In, Last Out - the first element added is the last to be removed

Solution

1. Step 1: Understand LIFO meaning

   LIFO means the last item you put in is the first one you take out.

2. Step 2: Apply to stack behavior

   Stacks follow LIFO, so the last pushed element is popped first.

3. Final Answer:

   Last In, First Out - the last element added is the first to be removed -> Option C

4. Quick Check:

   LIFO = Last In, First Out [OK]

Hint: Remember stack is like a stack of plates, last added removed first [OK]

Common Mistakes:

• Confusing LIFO with FIFO
• Thinking first added is removed first
• Mixing up the order of insertion and removal

2. Which of the following is the correct way to push an integer 10 onto a stack named myStack in C#?

easy

A. myStack.Enqueue(10);

B. myStack.Push(10);

C. myStack.Insert(10);

D. myStack.Add(10);

Solution

1. Step 1: Recall stack push method

   In C#, the method to add an element to a stack is Push.

2. Step 2: Check method names

   Add and Insert are not stack methods; Enqueue is for queues.

3. Final Answer:

   myStack.Push(10); -> Option B

4. Quick Check:

   Push() adds element to stack [OK]

Hint: Use Push() to add elements to stack in C# [OK]

Common Mistakes:

• Using Add() or Insert() which are not stack methods
• Confusing stack with queue methods like Enqueue()
• Forgetting parentheses in method call

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

Stack<int> stack = new Stack<int>();
stack.Push(5);
stack.Push(10);
stack.Push(15);
Console.WriteLine(stack.Pop());
Console.WriteLine(stack.Peek());

medium

A. 15
10

B. 5
10

C. 10
15

D. 15
15

Solution

1. Step 1: Trace Push operations

   Elements pushed in order: 5 (bottom), 10, 15 (top).

2. Step 2: Trace Pop and Peek

   Pop removes and returns 15 (top). Peek returns new top 10 without removing.

3. Final Answer:

   15\n10 -> Option A

4. Quick Check:

   Pop() = 15, Peek() = 10 [OK]

Hint: Pop returns top and removes it; Peek returns top without removing [OK]

Common Mistakes:

• Mixing Pop and Peek outputs
• Assuming Pop does not remove element
• Confusing order of pushed elements

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

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

medium

A. Stack must be initialized with capacity

B. Pop() cannot be assigned to a string variable

C. Push() method requires two arguments

D. Stack does not have a method named Top()

Solution

1. Step 1: Check stack methods

   Stack in C# has Peek() to view top element, not Top().

2. Step 2: Validate other statements

   Pop() returns string, Push() takes one argument, no capacity needed.

3. Final Answer:

   Stack does not have a method named Top() -> Option D

4. Quick Check:

   Use Peek() to view top element [OK]

Hint: Use Peek() to see top element, not Top() [OK]

Common Mistakes:

• Using Top() instead of Peek()
• Thinking Pop() returns void
• Assuming Push() needs capacity argument

5. Given a stack with elements pushed in this order: 1, 2, 3, 4, 5. You pop two elements, then push 6 and 7. What is the order of elements if you pop all remaining elements one by one?

hard

A. 7, 6, 3, 2, 1

B. 3, 2, 6, 7

C. 5, 4, 6, 7

D. 7, 6, 3, 2

Solution

1. Step 1: Track initial pushes

   Stack after pushes: bottom 1,2,3,4,5 top.

2. Step 2: Pop two elements

   Pop removes 5 then 4; stack now 1,2,3 (bottom to top).

3. Step 3: Push 6 and 7

   Stack now: 1,2,3,6,7 (bottom to top).

4. Step 4: Pop all remaining elements

   Pop order (first popped to last): 7,6,3,2,1.

5. Final Answer:

   7, 6, 3, 2, 1 -> Option A

6. Quick Check:

   Pop order after operations = 7,6,3,2,1 [OK]

Hint: Pop removes last pushed; track pushes and pops stepwise [OK]

Common Mistakes:

• Forgetting to remove popped elements
• Mixing push and pop order
• Ignoring elements still in stack after operations