Why Stack Exists and What Problems It Solves in DSA Typescript - Why It Works

Concept Flow - Why Stack Exists and What Problems It Solves

Start: Need to store data temporarily

↓

Choose Stack: LIFO order

↓

Push: Add item on top

↓

Pop: Remove item from top

↓

Use Cases: Undo, Function Calls, Expression Eval

↓

Problem Solved: Manage order of tasks/data easily

Stack stores data in last-in, first-out order, helping solve problems needing reverse or nested order handling.

Execution Sample

DSA Typescript

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

This code adds 1 and 2 to the stack, removes the last added (2), then shows the remaining stack.

Execution Table

Step	Operation	Stack State Before	Action	Stack State After	Visual State
1	Initialize stack	[]	Create empty stack	[]	Top -> null
2	Push 1	[]	Add 1 on top	[1]	Top -> 1 -> null
3	Push 2	[1]	Add 2 on top	[1, 2]	Top -> 2 -> 1 -> null
4	Pop	[1, 2]	Remove top (2)	[1]	Top -> 1 -> null
5	Print stack	[1]	Output stack	[1]	Top -> 1 -> null

💡 Stack operations complete; final stack has one element [1]

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	Final
stack	[]	[1]	[1, 2]	[1]	[1]

Key Moments - 3 Insights

Why does pop remove the last pushed item, not the first?

Because stack follows Last-In-First-Out (LIFO) order, shown in execution_table step 4 where pop removes 2, the last pushed.

What happens if we pop from an empty stack?

Popping from empty stack returns undefined or error; here stack was never empty before pop (see step 4), so no error.

Why use stack instead of array for some problems?

Stack restricts access to only top element, enforcing order needed in problems like undo or function calls, unlike general arrays.

Visual Quiz - 3 Questions

Look at the execution_table, what is the stack state after step 3?

A [1, 2]

B [1]

C []

D [2]

💡 Hint

Check the 'Stack State After' column for step 3 in execution_table

At which step does the stack remove an element?

A Step 2

B Step 4

C Step 3

D Step 5

💡 Hint

Look for 'Pop' operation in execution_table

If we push 3 after step 4, what will be the new top of the stack?

A 1

B 2

C 3

D Empty

💡 Hint

After popping 2, pushing 3 adds it on top (see push steps in execution_table)

Concept Snapshot

Stack stores data in Last-In-First-Out (LIFO) order.
Use push() to add on top, pop() to remove from top.
Solves problems needing reverse or nested order like undo or function calls.
Only top element is accessible, enforcing strict order.
Simple and efficient for temporary data storage.

Full Transcript

A stack is a data structure that stores items in a last-in, first-out order. You add items using push, which puts them on top, and remove items using pop, which takes from the top. This order helps solve problems where the most recent item must be handled first, like undo actions or managing function calls. The example code shows pushing 1 and 2, then popping the last item (2), leaving 1 in the stack. The execution table tracks these changes step by step. Understanding why pop removes the last pushed item is key, as is knowing that popping from an empty stack can cause errors. Stacks restrict access to only the top element, unlike arrays, making them ideal for certain tasks.

Practice

1. Why do we use a stack data structure in programming?

easy

A. To sort numbers in ascending order automatically

B. To store data in random order for quick access

C. To keep track of function calls and return in the correct order

D. To store large amounts of data permanently

Solution

1. Step 1: Understand the purpose of a stack

   A stack stores items in Last In First Out (LIFO) order, which is perfect for tracking function calls.

2. Step 2: Relate stack to function calls

   When a function calls another, the current function is paused and saved on the stack. When the called function finishes, the program returns to the last saved function.

3. Final Answer:

   To keep track of function calls and return in the correct order -> Option C

4. Quick Check:

   Stack = function call tracking [OK]

Hint: Stack follows LIFO, perfect for tracking nested calls [OK]

Common Mistakes:

• Thinking stack stores data randomly
• Confusing stack with queue
• Assuming stack sorts data automatically

2. Which of the following is the correct way to push an element '5' onto a stack named myStack in TypeScript?

easy

A. myStack.push(5);

B. myStack.add(5);

C. myStack.insert(5);

D. myStack.enqueue(5);

Solution

1. Step 1: Recall stack method names in TypeScript

   Stacks use push() to add elements on top.

2. Step 2: Identify correct method for adding element

   push() is the standard method; others like add(), insert(), or enqueue() are not used for stacks.

3. Final Answer:

   myStack.push(5); -> Option A

4. Quick Check:

   Push adds element on top [OK]

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

Common Mistakes:

• Using enqueue which is for queues
• Using add or insert which are not stack methods
• Confusing push with pop

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

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

medium

A. [30]

B. [10, 20, 30]

C. [20, 30]

D. [10, 30]

Solution

1. Step 1: Trace stack operations step-by-step

   Initially stack is empty []. Push 10 -> [10]. Push 20 -> [10, 20]. Pop removes 20 -> [10]. Push 30 -> [10, 30].

2. Step 2: Determine final stack content

   After all operations, stack contains [10, 30].

3. Final Answer:

   [10, 30] -> Option D

4. Quick Check:

   Push/pop changes stack top [OK]

Hint: Pop removes last pushed element [OK]

Common Mistakes:

• Forgetting pop removes top element
• Assuming pop returns stack without removing
• Mixing order of push and pop

4. Find the error in this TypeScript stack usage code:

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

medium

A. Stack does not have a peek() method by default

B. push() method is used incorrectly

C. stack should be declared as Stack<number> not number[]

D. console.log cannot print stack elements

Solution

1. Step 1: Check methods available on array used as stack

   TypeScript arrays have push() and pop(), but no peek() method by default.

2. Step 2: Identify cause of error

   Calling stack.peek() will cause a runtime error because peek() is not defined.

3. Final Answer:

   Stack does not have a peek() method by default -> Option A

4. Quick Check:

   peek() missing in array stack [OK]

Hint: Array stack has pop(), no peek() [OK]

Common Mistakes:

• Assuming peek() exists on arrays
• Thinking push() is wrong
• Confusing type declaration with method error

5. You want to reverse a string using a stack in TypeScript. Which approach correctly uses a stack to reverse the string "hello"?

hard

A. Push characters and pop in same order to keep string unchanged

B. Push each character onto stack, then pop all to build reversed string

C. Use stack to sort characters alphabetically

D. Push entire string onto stack, then pop once to get reversed string

Solution

1. Step 1: Understand stack reversal logic

   Pushing characters one by one stores them in order. Popping them reverses the order because stack is LIFO.

2. Step 2: Apply to string reversal

   Push 'h', 'e', 'l', 'l', 'o' then pop all to get 'o', 'l', 'l', 'e', 'h' which is reversed string.

3. Final Answer:

   Push each character onto stack, then pop all to build reversed string -> Option B

4. Quick Check:

   Stack LIFO reverses order [OK]

Hint: Push chars, pop all to reverse string [OK]

Common Mistakes:

• Pushing entire string at once
• Popping in same order as push
• Using stack for sorting instead of reversing