Why Stack Exists and What Problems It Solves in DSA Rust - Challenge Your Understanding

Challenge - 5 Problems

🧠 Conceptual

intermediate

Why do we use a stack data structure?

Which of the following best explains why a stack is useful in programming?

A It is mainly used to store key-value pairs for fast lookup.

B It stores data in a random order to allow quick access to any element.

C It organizes data in a way that always retrieves the smallest element first.

D It helps keep track of the order of function calls and supports undo operations by following last-in, first-out order.

💡 Hint

Think about how you reverse actions or remember the last thing you did.

A stack follows last-in, first-out (LIFO) order, which is perfect for tracking function calls and undo operations where the most recent action is reversed first.

❓ Predict Output

intermediate

Stack Push and Pop Operations Output

What is the printed output after running this Rust code that uses a stack?

DSA Rust

fn main() {
    let mut stack = Vec::new();
    stack.push(10);
    stack.push(20);
    println!("{}", stack.pop().unwrap());
    stack.push(30);
    println!("{}", stack.pop().unwrap());
    println!("{}", stack.pop().unwrap());
}

A

20
30
10

B

10
20
30

C

30
20
10

D

10
30
20

💡 Hint

Remember that stack pop removes the last pushed item.

The stack pushes 10, then 20. The first pop removes 20. Then 30 is pushed. The next pop removes 30, and the last pop removes 10.

🔧 Debug

advanced

Identify the error in stack usage

What error will this Rust code produce when run?

DSA Rust

fn main() {
    let mut stack = Vec::new();
    stack.push(5);
    stack.pop();
    println!("{}", stack.pop().unwrap());
}

A TypeError because pop returns an integer, not an Option

B panic at 'called `Option::unwrap()` on a `None` value'

C Prints 5

D SyntaxError due to missing semicolon

💡 Hint

Consider what happens when you pop from an empty stack.

After popping once, the stack is empty. Calling pop again returns None, and unwrap on None causes a panic.

🚀 Application

advanced

Using Stack to Reverse a String

Which Rust code snippet correctly uses a stack to reverse the string "hello"?

A

let s = "hello";
let mut stack = Vec::new();
for ch in s.chars() {
    stack.insert(0, ch);
}
let reversed: String = stack.into_iter().collect();
println!("{}", reversed);

B

let s = "hello";
let mut stack = Vec::new();
for ch in s.chars() {
    stack.push(ch);
}
let reversed: String = stack.into_iter().collect();
println!("{}", reversed);

C

let s = "hello";
let mut stack = Vec::new();
for ch in s.chars() {
    stack.push(ch);
}
let reversed: String = stack.into_iter().rev().collect();
println!("{}", reversed);

D

let s = "hello";
let mut stack = Vec::new();
for ch in s.chars() {
    stack.push(ch);
}
let reversed: String = stack.iter().collect();
println!("{}", reversed);

💡 Hint

Think about how popping from a stack reverses order.

Pushing characters onto the Vec (stack) stores them in original order. Option C uses into_iter().rev() to collect from the end (top of stack) first, simulating LIFO pops and reversing "hello" to "olleh".

🧠 Conceptual

expert

Stack Usage in Function Call Management

Why is a stack the ideal data structure for managing function calls in programming languages?

A Because it allows the program to return to the most recent function call after completing the current one, following last-in, first-out order.

B Because it allows parallel execution of all function calls simultaneously.

C Because it stores all function calls in alphabetical order for quick lookup.

D Because it stores function calls in a queue to process them in the order they were called.

💡 Hint

Think about how functions call other functions and then return back.

Function calls are nested. The last function called must finish first before returning to the previous one. A stack naturally supports this last-in, first-out behavior.

Practice

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

easy

A. To keep track of function calls and return addresses

B. To store data in random order

C. To sort elements automatically

D. To store large amounts of data permanently

Solution

1. Step 1: Understand the role of stack in function calls

   Stacks help keep track of where each function should return after it finishes executing, by storing return addresses.

2. Step 2: Compare with other options

   Stacks do not sort data automatically, nor store data randomly or permanently; their main use is managing function calls.

3. Final Answer:

   To keep track of function calls and return addresses -> Option A

4. Quick Check:

   Stack = function call tracking [OK]

Hint: Stack remembers last function called first [OK]

Common Mistakes:

• Thinking stack sorts data automatically
• Confusing stack with permanent storage
• Assuming stack stores data randomly

2. Which of the following is the correct way to push an element onto a stack in Rust using a vector?

easy

A. stack.insert(element);

B. stack.add(element);

C. stack.append(element);

D. stack.push(element);

Solution

1. Step 1: Recall Rust vector methods for stack operations

   In Rust, a vector's push() method adds an element to the end, simulating stack push.

2. Step 2: Check other options for correctness

   Methods add(), insert(), and append() do not exist or do not behave like push() for stack usage.

3. Final Answer:

   stack.push(element); -> Option D

4. Quick Check:

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

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

Common Mistakes:

• Using add() which is not a Rust Vec method
• Confusing insert() which needs index
• Using append() which merges vectors

3. What will be the output of the following Rust code snippet?

let mut stack = Vec::new();
stack.push(10);
stack.push(20);
let top = stack.pop();
println!("{:?}", top);

medium

A. Some(20)

B. Some(10)

C. 20

D. None

Solution

1. Step 1: Trace stack push operations

   First 10 is pushed, then 20 is pushed. Stack now has [10, 20].

2. Step 2: Understand pop() behavior

   pop() removes and returns the last element, which is 20, wrapped in Some(20) because pop returns Option.

3. Final Answer:

   Some(20) -> Option A

4. Quick Check:

   pop() returns last element wrapped in Some [OK]

Hint: pop() returns Option with last pushed element [OK]

Common Mistakes:

• Expecting pop() to return raw value, not Option
• Confusing order of elements pushed
• Thinking pop() returns None when stack is not empty

4. Identify the error in this Rust code that uses a stack:

let mut stack = Vec::new();
let top = stack.pop().unwrap();
println!("{}", top);

medium

A. println! macro syntax is incorrect

B. Calling unwrap() on empty stack causes panic

C. stack should be immutable

D. pop() method does not exist on Vec

Solution

1. Step 1: Analyze pop() on empty vector

   pop() returns None if vector is empty. Calling unwrap() on None causes panic (runtime error).

2. Step 2: Check other options for validity

   pop() exists on Vec, stack is mutable, and println! syntax is correct.

3. Final Answer:

   Calling unwrap() on empty stack causes panic -> Option B

4. Quick Check:

   unwrap() on None panics [OK]

Hint: Never unwrap pop() without checking empty [OK]

Common Mistakes:

• Ignoring possibility of empty stack
• Thinking pop() is undefined on Vec
• Assuming println! syntax is wrong

5. You want to reverse a list of integers using a stack in Rust. Which approach correctly uses a stack to reverse the list?

let list = vec![1, 2, 3, 4];
let mut stack = Vec::new();
// Fill stack
for &item in &list {
    stack.push(item);
}
// Extract reversed list
let mut reversed = Vec::new();
while let Some(val) = stack.pop() {
    reversed.push(val);
}
println!("{:?}", reversed);

hard

A. Stack is not needed; list.reverse() is better

B. pop() should be replaced with peek() to reverse

C. This code correctly reverses the list using a stack

D. The code will panic because stack is empty

Solution

1. Step 1: Understand pushing all elements onto stack

   Each element from list is pushed onto stack in order: 1,2,3,4.

2. Step 2: Popping elements reverses order

   pop() removes last pushed element first, so reversed vector gets 4,3,2,1.

3. Step 3: Confirm no panic occurs

   while let Some(val) safely handles empty stack, no panic occurs.

4. Final Answer:

   This code correctly reverses the list using a stack -> Option C

5. Quick Check:

   Stack pop reverses order [OK]

Hint: Push all, then pop all to reverse [OK]

Common Mistakes:

• Replacing pop() with peek() which doesn't remove
• Assuming code panics on empty stack
• Ignoring that stack reverses order naturally