Check if Stack is Empty or Full in DSA Rust - Build from Scratch

Check if Stack is Empty or Full

📖 Scenario: You are building a simple stack to manage books in a small library cart. The cart can hold only a limited number of books. You want to check if the cart is empty or full before adding or removing books.

🎯 Goal: Create a stack with a fixed size, add some books, then check if the stack is empty or full.

📋 What You'll Learn

Create a stack vector called stack with a maximum size of 3

Create a variable max_size set to 3

Add two books to the stack vector

Write code to check if the stack is empty using stack.is_empty()

Write code to check if the stack is full by comparing stack.len() with max_size

Print the results of the empty and full checks

💡 Why This Matters

🌍 Real World

Stacks are used in many real-world applications like undo features in text editors, managing function calls, and browser history.

💼 Career

Understanding stack operations and checks is fundamental for software development roles, especially those involving system programming, algorithms, and data structure design.

1

Create the stack vector

Create a vector called stack that will hold String values. Initialize it as empty.

DSA Rust

# Create an empty vector called stack to hold String values
# Your code here

Hint

Use Vec::new() to create an empty vector. Remember to make it mutable with mut.

2

Set the maximum size of the stack

Create a variable called max_size and set it to 3.

DSA Rust

fn main() {
    let mut stack: Vec = Vec::new();
    
    // Create max_size variable and set it to 3
    # Your code here
}

Hint

Use let max_size = 3; to create the variable.

3

Add two books to the stack

Add two books to the stack vector using push. Add "Book A" and "Book B" as String values.

DSA Rust

fn main() {
    let mut stack: Vec = Vec::new();
    let max_size = 3;
    
    // Add "Book A" and "Book B" to stack
    # Your code here
}

Hint

Use stack.push(String::from("Book A")); to add a book.

4

Check if stack is empty or full and print results

Write code to check if stack is empty using stack.is_empty() and if it is full by comparing stack.len() with max_size. Print "Stack is empty: " followed by the empty check result, and "Stack is full: " followed by the full check result.

DSA Rust

fn main() {
    let mut stack: Vec = Vec::new();
    let max_size = 3;
    stack.push(String::from("Book A"));
    stack.push(String::from("Book B"));
    
    // Check if stack is empty and full, then print results
    # Your code here
}

Hint

Use stack.is_empty() and stack.len() == max_size to check. Use println! to print.

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