Stack Concept and LIFO Principle in DSA Typescript

Mental Model

A stack is a collection where the last item added is the first one removed. This is called Last In, First Out (LIFO).

Analogy: Think of a stack of plates: you put a new plate on top and take plates from the top only.

Top
 ↑
[ 3 ]
[ 2 ]
[ 1 ]
Bottom
null

Dry Run Walkthrough

Input: Start with empty stack, push 1, push 2, push 3, then pop once

Goal: Show how items are added and removed following LIFO order

Step 1: Push 1 onto empty stack

Top ↑
[ 1 ]
Bottom
null

Why: First item goes on top, stack was empty

Step 2: Push 2 on top of 1

Top ↑
[ 2 ]
[ 1 ]
Bottom
null

Why: New item goes on top, above previous items

Step 3: Push 3 on top of 2

Top ↑
[ 3 ]
[ 2 ]
[ 1 ]
Bottom
null

Why: Keep adding on top, last pushed is on top

Step 4: Pop top item (3) from stack

Top ↑
[ 2 ]
[ 1 ]
Bottom
null

Why: Remove the last added item first, following LIFO

Result:

Top ↑
[ 2 ]
[ 1 ]
Bottom
null
Popped value: 3

Annotated Code

DSA Typescript

class Stack {
  private items: number[] = [];

  push(value: number): void {
    this.items.push(value); // add value on top
  }

  pop(): number | undefined {
    return this.items.pop(); // remove and return top value
  }

  print(): void {
    console.log('Top ↑');
    for (let i = this.items.length - 1; i >= 0; i--) {
      console.log(`[ ${this.items[i]} ]`);
    }
    console.log('Bottom');
    console.log('null');
  }
}

// Driver code
const stack = new Stack();
stack.push(1);
stack.push(2);
stack.push(3);
stack.print();
const popped = stack.pop();
stack.print();
console.log('Popped value:', popped);

this.items.push(value); // add value on top

Add new item at the end of array representing top of stack

return this.items.pop(); // remove and return top value

Remove last item from array, which is the top of stack

Output

Top ↑

[ 3 ]

[ 2 ]

[ 1 ]

Bottom

null

Top ↑

[ 2 ]

[ 1 ]

Bottom

null

Popped value: 3

Complexity Analysis

Time: O(1) for push and pop because adding/removing from end of array is constant time

Space: O(n) because stack stores all pushed items in an array

vs Alternative: Compared to a queue where removal is from front (O(n) in array), stack operations are faster and simpler with O(1)

Edge Cases

Pop from empty stack

Returns undefined safely without error

DSA Typescript

return this.items.pop(); // remove and return top value

When to Use This Pattern

When you see a problem needing last added item accessed first, think stack and LIFO principle for simple push/pop operations.

Common Mistakes

Mistake: Removing items from the start of the array instead of the end
Fix: Use array's push and pop methods to add/remove from the end, preserving LIFO

Summary

Stack stores items so the last added is the first removed (LIFO).

Use stack when you need to reverse order or track recent items first.

Remember: push adds on top, pop removes from top, like a plate stack.

Practice

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

easy

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

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

C. First In, First Out - the first 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 element added to the stack is the first one to be removed.

2. Step 2: Match with options

   Last In, First Out - the last element added is the first to be removed correctly describes this behavior as "Last In, First Out".

3. Final Answer:

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

4. Quick Check:

   LIFO = Last In, First Out [OK]

Hint: Remember stack removes newest item 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 TypeScript syntax to push an element `5` onto a stack array named stack?

easy

A. stack.push(5);

B. stack.add(5);

C. stack.insert(5);

D. stack.append(5);

Solution

1. Step 1: Recall array method to add element at end

   In TypeScript, the method to add an element at the end of an array is push().

2. Step 2: Verify options

   Only stack.push(5); uses push(5), which is correct syntax to add 5 to the stack.

3. Final Answer:

   stack.push(5); -> Option A

4. Quick Check:

   Use push() to add element to stack [OK]

Hint: Use push() to add elements to stack [OK]

Common Mistakes:

• Using non-existent methods like add or insert
• Confusing push with append (not in JS/TS)
• Syntax errors like missing parentheses

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

const stack: number[] = [];
stack.push(10);
stack.push(20);
stack.push(30);
const popped = stack.pop();
console.log(stack);

medium

A. [10, 20, 30]

B. [20, 30]

C. [10, 20]

D. [30]

Solution

1. Step 1: Trace push operations

   Elements 10, 20, and 30 are pushed in order, so stack becomes [10, 20, 30].

2. Step 2: Trace pop operation

   Pop removes the last element (30), so stack becomes [10, 20].

3. Final Answer:

   [10, 20] -> Option C

4. Quick Check:

   Pop removes last item, stack left with [10, 20] [OK]

Hint: Pop removes last pushed element [OK]

Common Mistakes:

• Thinking pop removes first element
• Confusing push and pop effects
• Expecting stack unchanged after pop

4. Identify the error in the following TypeScript stack code:

const stack: number[] = [];
stack.push(1);
stack.push(2);
const removed = stack.pop;
console.log(removed);

medium

A. console.log syntax is wrong

B. stack array is not initialized

C. push method is used incorrectly

D. pop method is not called with parentheses

Solution

1. Step 1: Check pop usage

   The code assigns stack.pop without parentheses, so it assigns the function itself, not the popped value.

2. Step 2: Correct usage

   To pop and get the value, it should be stack.pop() with parentheses to call the method.

3. Final Answer:

   pop method is not called with parentheses -> Option D

4. Quick Check:

   Call pop() with () to execute [OK]

Hint: Always use parentheses to call pop() [OK]

Common Mistakes:

• Forgetting parentheses on pop()
• Confusing method reference with method call
• Assuming pop returns function instead of value

5. Given a stack implemented as an array, which sequence of operations will result in the stack containing [1, 2, 3] after all operations?

Choose the correct sequence:
A) push(1), push(2), pop(), push(3), push(2)
B) push(1), pop(), push(2), push(3), push(1)
C) push(3), push(2), push(1), pop(), push(1)
D) push(1), push(2), push(3), pop(), push(3)

hard

A. push(1), push(2), pop(), push(3), push(2)

B. push(1), push(2), push(3), pop(), push(3)

C. push(3), push(2), push(1), pop(), push(1)

D. push(1), pop(), push(2), push(3), push(1)

Solution

1. Step 1: Trace push(1), push(2), push(3), pop(), push(3) operations

   Start with empty stack []:
   push(1) -> [1]
   push(2) -> [1, 2]
   push(3) -> [1, 2, 3]
   pop() removes 3 -> [1, 2]
   push(3) -> [1, 2, 3]

2. Step 2: Verify final stack

   After these operations, stack is [1, 2, 3], matching the target.

3. Final Answer:

   push(1), push(2), push(3), pop(), push(3) -> Option B

4. Quick Check:

   Pop removes last, push adds correct element [OK]

Hint: Trace each push/pop step carefully [OK]

Common Mistakes:

• Not tracking pop effect correctly
• Assuming pop removes first element
• Mixing order of pushes and pops