Check if Stack is Empty or Full in DSA Rust - Execution Trace

Concept Flow - Check if Stack is Empty or Full

Start

↓

Check if top == -1?

Yes→Stack is Empty

|No↓

Check if top == max_size - 1?

Yes→Stack is Full

|No↓

Stack has space

↓

End

The flow checks the top pointer to decide if the stack is empty or full before any push or pop operation.

Execution Sample

DSA Rust

let mut stack = Stack::new(3);
println!("Empty? {}", stack.is_empty());
stack.push(10);
stack.push(20);
println!("Full? {}", stack.is_full());

This code creates a stack of size 3, checks if it is empty, pushes two elements, then checks if it is full.

Execution Table

Step	Operation	Top Pointer	Stack Content	Is Empty?	Is Full?	Visual State
1	Create stack with max_size=3	-1	[]	True	False	Empty stack: []
2	Check is_empty()	-1	[]	True	False	Stack is empty
3	Push 10	0	[10]	False	False	Stack: 10 -> null
4	Push 20	1	[10, 20]	False	False	Stack: 20 -> 10 -> null
5	Check is_full()	1	[10, 20]	False	False	Stack not full (top=1, max=2)
6	Push 30	2	[10, 20, 30]	False	True	Stack: 30 -> 20 -> 10 -> null
7	Check is_full()	2	[10, 20, 30]	False	True	Stack is full
8	Attempt push 40 (ignored)	2	[10, 20, 30]	False	True	Stack full, push ignored
9	End	2	[10, 20, 30]	False	True	Final stack state

💡 Stack top reached max_size - 1, so stack is full and no more pushes allowed.

Variable Tracker

Variable	Start	After Step 3	After Step 4	After Step 6	Final
top	-1	0	1	2	2
stack array	[]	[10]	[10, 20]	[10, 20, 30]	[10, 20, 30]
is_empty	True	False	False	False	False
is_full	False	False	False	True	True

Key Moments - 3 Insights

Why does the stack start with top = -1 instead of 0?

The top = -1 means the stack is empty (no elements). This is shown in execution_table step 1 and 2 where top is -1 and stack is empty.

Why does is_full check if top == max_size - 1?

Because array indices start at 0, the last valid index is max_size - 1. When top reaches this, the stack is full, as shown in steps 6 and 7.

What happens if we try to push when the stack is full?

The push operation is ignored or rejected to prevent overflow. This is shown in step 8 where top stays at 2 and stack content does not change.

Visual Quiz - 3 Questions

Look at the execution_table at step 4, what is the value of 'top'?

A 1

B 0

C 2

D -1

💡 Hint

Check the 'Top Pointer' column in execution_table row for step 4.

At which step does the stack become full?

A Step 5

B Step 6

C Step 7

D Step 8

💡 Hint

Look at the 'Is Full?' column and 'Top Pointer' in execution_table rows.

If max_size was 4 instead of 3, what would change in the execution_table?

A Top pointer starts at 0

B Stack becomes empty at top = 0

C Stack becomes full at top = 3 instead of 2

D Push operations would be ignored earlier

💡 Hint

Recall that is_full checks top == max_size - 1, so increasing max_size changes when full condition triggers.

Concept Snapshot

Stack uses a 'top' pointer starting at -1 for empty.
Check empty: top == -1.
Check full: top == max_size - 1.
Push increments top if not full.
Pop decrements top if not empty.
Prevents overflow and underflow.

Full Transcript

This concept shows how to check if a stack is empty or full by looking at the 'top' pointer. The stack starts empty with top = -1. When top equals max_size - 1, the stack is full. The execution steps show creating a stack, checking empty, pushing elements, checking full, and handling push when full. Variables like top and stack content change accordingly. Key moments clarify why top starts at -1 and how full condition works. The quiz tests understanding of top pointer values and full condition changes.

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