Check if Stack is Empty or Full in DSA Rust - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does it mean for a stack to be empty?

A stack is empty when it has no elements inside it. This means there is nothing to pop or peek.

beginner

How can you check if a stack is full in a fixed-size stack?

A stack is full when the number of elements reaches its maximum capacity. You check if the top index equals the maximum size minus one.

beginner

In Rust, what data structure property helps to check if a stack is empty?

You can check if the vector (Vec) used for the stack has length zero using the is_empty() method.

beginner

Why is it important to check if a stack is empty before popping?

Popping from an empty stack causes errors or crashes because there is no element to remove.

intermediate

What is a simple Rust code snippet to check if a stack is full given a max size?

if stack.len() == max_size { /* stack is full */ } else { /* not full */ }

What does stack.is_empty() return in Rust when the stack has no elements?

A None

B false

C 0

D true

The is_empty() method returns true if the stack has zero elements.

If a stack has max size 5, when is it considered full?

A When it has 5 elements

B When it has 0 elements

C When it has 6 elements

D When it has 4 elements

A stack is full when it reaches its maximum capacity, which is 5 elements here.

What happens if you pop from an empty stack?

A You get the last element

B It causes an error or panic

C Nothing happens

D The stack becomes full

Popping from an empty stack causes an error because there is no element to remove.

Which Rust method checks if a vector is empty?

A is_empty()

B len()

C pop()

D push()

The is_empty() method returns true if the vector has no elements.

How do you check if a stack is full in Rust if you know max_size?

A stack.is_empty()

B stack.len() > max_size

C stack.len() == max_size

D stack.len() < max_size

When the stack length equals max_size, the stack is full.

Explain how to check if a stack is empty or full in Rust using a vector and max size.

Think about vector length and max capacity.

Describe why checking stack state (empty/full) is important in stack operations.

Consider what happens if you ignore these checks.

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