Check if Stack is Empty or Full in DSA Rust - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output after pushing elements to the stack?

Consider a stack with a maximum size of 3. We push elements 10, 20, and 30 in order. What is the printed state of the stack after these operations?

DSA Rust

use std::vec::Vec;

struct Stack {
    data: Vec<i32>,
    max_size: usize,
}

impl Stack {
    fn new(size: usize) -> Self {
        Stack { data: Vec::new(), max_size: size }
    }

    fn push(&mut self, value: i32) -> bool {
        if self.data.len() < self.max_size {
            self.data.push(value);
            true
        } else {
            false
        }
    }

    fn print(&self) {
        for val in &self.data {
            print!("{} -> ", val);
        }
        println!("null");
    }
}

fn main() {
    let mut stack = Stack::new(3);
    stack.push(10);
    stack.push(20);
    stack.push(30);
    stack.print();
}

A 10 -> 20 -> null

B 10 -> 20 -> 30 -> null

C 30 -> 20 -> 10 -> null

D null

💡 Hint

Remember that elements are pushed in order and printed in the order they are stored in the vector.

The stack stores elements in a vector. Pushing 10, then 20, then 30 adds them in that order. Printing iterates from the first to last element, so output is 10 -> 20 -> 30 -> null.

❓ Predict Output

intermediate

What does the is_empty method return after popping all elements?

Given a stack with max size 2, we push 5 and 15, then pop twice. What is the output of is_empty() after these operations?

DSA Rust

use std::vec::Vec;

struct Stack {
    data: Vec<i32>,
    max_size: usize,
}

impl Stack {
    fn new(size: usize) -> Self {
        Stack { data: Vec::new(), max_size: size }
    }

    fn push(&mut self, value: i32) -> bool {
        if self.data.len() < self.max_size {
            self.data.push(value);
            true
        } else {
            false
        }
    }

    fn pop(&mut self) -> Option<i32> {
        self.data.pop()
    }

    fn is_empty(&self) -> bool {
        self.data.is_empty()
    }
}

fn main() {
    let mut stack = Stack::new(2);
    stack.push(5);
    stack.push(15);
    stack.pop();
    stack.pop();
    println!("{}", stack.is_empty());
}

A false

B Compilation error

C true

D Runtime panic

💡 Hint

Check if the stack has any elements left after popping twice.

After pushing two elements and popping twice, the stack is empty. The is_empty method returns true when no elements remain.

❓ Predict Output

advanced

What is the output when pushing beyond stack capacity?

A stack has max size 2. We push 1, 2, then try to push 3. What is the output of the push method calls?

DSA Rust

use std::vec::Vec;

struct Stack {
    data: Vec<i32>,
    max_size: usize,
}

impl Stack {
    fn new(size: usize) -> Self {
        Stack { data: Vec::new(), max_size: size }
    }

    fn push(&mut self, value: i32) -> bool {
        if self.data.len() < self.max_size {
            self.data.push(value);
            true
        } else {
            false
        }
    }
}

fn main() {
    let mut stack = Stack::new(2);
    println!("{}", stack.push(1));
    println!("{}", stack.push(2));
    println!("{}", stack.push(3));
}

A

true
true
false

B

true
false
false

C

false
false
false

D

true
true
true

💡 Hint

The push method returns false if the stack is full.

The first two pushes succeed because the stack is not full. The third push fails because the stack reached max size 2.

❓ Predict Output

advanced

What error occurs when popping from an empty stack?

What happens if we pop from an empty stack in this Rust code?

DSA Rust

use std::vec::Vec;

struct Stack {
    data: Vec<i32>,
}

impl Stack {
    fn new() -> Self {
        Stack { data: Vec::new() }
    }

    fn pop(&mut self) -> i32 {
        self.data.pop().unwrap()
    }
}

fn main() {
    let mut stack = Stack::new();
    stack.pop();
}

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

B Returns 0

C Compilation error

D Returns None

💡 Hint

unwrap() on None causes a runtime panic.

Calling unwrap() on None causes the program to panic with a message about unwrap on None value.

🧠 Conceptual

expert

Which condition correctly checks if the stack is full?

Given a stack struct with a vector data and max_size, which condition correctly checks if the stack is full?

A self.data.len() < self.max_size

B self.data.is_empty()

C self.data.len() > self.max_size

D self.data.len() == self.max_size

💡 Hint

Full means the number of elements equals max size.

The stack is full when the number of elements equals max_size. Less means not full, greater should not happen.

Practice

1. What does the is_empty() method of a stack typically check?

easy

A. If the stack has more than one element

B. If the stack is full and cannot accept more elements

C. If the stack has exactly one element

D. If the stack has no elements inside

Solution

1. Step 1: Understand the purpose of is_empty()

   This method checks whether the stack contains any elements or not.

2. Step 2: Interpret the meaning of empty stack

   An empty stack means it has zero elements inside, so is_empty() returns true only in this case.

3. Final Answer:

   If the stack has no elements inside -> Option D

4. Quick Check:

   Empty stack means no elements [OK]

Hint: Empty means zero elements inside the stack [OK]

Common Mistakes:

• Confusing empty with full
• Thinking empty means one element
• Assuming empty means stack is null

2. Which of the following is the correct Rust syntax to check if a stack named stack is full assuming it has a fixed capacity stored in capacity and current size in size?

easy

A. if stack.len() == capacity { /* full */ }

B. if stack.size == capacity { /* full */ }

C. if stack.is_full() { /* full */ }

D. if stack.size > capacity { /* full */ }

Solution

1. Step 1: Identify how to get current stack size

   In Rust, len() method is commonly used to get the current number of elements in a collection like a stack.

2. Step 2: Compare current size with capacity

   If stack.len() equals capacity, the stack is full.

3. Final Answer:

   if stack.len() == capacity { /* full */ } -> Option A

4. Quick Check:

   Use len() to check size [OK]

Hint: Use stack.len() to get current size in Rust [OK]

Common Mistakes:

• Using stack.size instead of stack.len()
• Checking size > capacity instead of == capacity
• Assuming is_full() method exists by default

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

struct Stack {
    elements: Vec<i32>,
    capacity: usize,
}

impl Stack {
    fn is_full(&self) -> bool {
        self.elements.len() == self.capacity
    }

    fn is_empty(&self) -> bool {
        self.elements.is_empty()
    }
}

fn main() {
    let stack = Stack { elements: vec![1, 2, 3], capacity: 3 };
    println!("{} {}", stack.is_empty(), stack.is_full());
}

medium

A. false true

B. true false

C. false false

D. true true

Solution

1. Step 1: Check if stack is empty

   The stack has elements [1, 2, 3], so is_empty() returns false.

2. Step 2: Check if stack is full

   The stack capacity is 3 and current length is 3, so is_full() returns true.

3. Final Answer:

   false true -> Option A

4. Quick Check:

   Elements present = not empty, length == capacity = full [OK]

Hint: Empty false if elements exist; full true if length equals capacity [OK]

Common Mistakes:

• Thinking stack is empty when it has elements
• Confusing is_empty() and is_full() return values
• Ignoring capacity when checking full

4. Identify the error in the following Rust code that checks if a stack is empty:

struct Stack {
    elements: Vec<i32>,
}

impl Stack {
    fn is_empty(&self) -> bool {
        self.elements.len() = 0
    }
}

medium

A. Vec<i32> cannot be used to store stack elements

B. Missing return type in is_empty method

C. Using '=' instead of '==' for comparison in is_empty method

D. is_empty method should take mutable self parameter

Solution

1. Step 1: Check the comparison operator in is_empty

   The code uses single '=' which is assignment, not comparison. It should use '==' to compare length with zero.

2. Step 2: Confirm other parts are correct

   The return type bool is present, Vec<i32> is valid, and self does not need to be mutable for this check.

3. Final Answer:

   Using '=' instead of '==' for comparison in is_empty method -> Option C

4. Quick Check:

   Use '==' for comparison, not '=' [OK]

Hint: Use '==' to compare values, '=' is assignment [OK]

Common Mistakes:

• Using '=' instead of '==' in conditions
• Forgetting return type bool
• Making self mutable unnecessarily

5. You have a stack with capacity 5 and current elements [10, 20, 30]. You want to write a Rust function can_push that returns true if the stack is not full and false otherwise. Which implementation is correct?

struct Stack {
    elements: Vec<i32>,
    capacity: usize,
}

impl Stack {
    fn can_push(&self) -> bool {
        // Choose correct condition
    }
}

hard

A. self.elements.len() <= self.capacity

B. self.elements.len() < self.capacity

C. self.elements.len() == self.capacity

D. self.elements.len() > self.capacity

Solution

1. Step 1: Understand when pushing is allowed

   You can push only if the stack is not full, meaning current size is less than capacity.

2. Step 2: Choose the correct comparison

   If length is less than capacity, pushing is possible. If equal or more, stack is full or invalid.

3. Final Answer:

   self.elements.len() < self.capacity -> Option B

4. Quick Check:

   Push allowed if size < capacity [OK]

Hint: Push allowed only if current size less than capacity [OK]

Common Mistakes:

• Using <= instead of < allows overflow
• Checking == means no room left
• Using > is logically incorrect