Queue Implementation Using Array in DSA Rust - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output after enqueue and dequeue operations?

Consider a queue implemented using a fixed-size array of length 5. Initially, the queue is empty. The following operations are performed in order:

1. enqueue(10)
2. enqueue(20)
3. enqueue(30)
4. dequeue()
5. enqueue(40)
6. dequeue()

What is the state of the queue after these operations?

DSA Rust

struct Queue {
    arr: [i32; 5],
    front: usize,
    rear: usize,
    size: usize,
}

impl Queue {
    fn new() -> Self {
        Queue { arr: [0; 5], front: 0, rear: 0, size: 0 }
    }

    fn enqueue(&mut self, val: i32) {
        if self.size == 5 { return; }
        self.arr[self.rear] = val;
        self.rear = (self.rear + 1) % 5;
        self.size += 1;
    }

    fn dequeue(&mut self) -> Option<i32> {
        if self.size == 0 { return None; }
        let val = self.arr[self.front];
        self.front = (self.front + 1) % 5;
        self.size -= 1;
        Some(val)
    }

    fn print_queue(&self) {
        let mut i = self.front;
        let mut count = self.size;
        while count > 0 {
            print!("{} -> ", self.arr[i]);
            i = (i + 1) % 5;
            count -= 1;
        }
        print!("null\n");
    }
}

fn main() {
    let mut q = Queue::new();
    q.enqueue(10);
    q.enqueue(20);
    q.enqueue(30);
    q.dequeue();
    q.enqueue(40);
    q.dequeue();
    q.print_queue();
}

A 10 -> 20 -> 30 -> 40 -> null

B 30 -> 40 -> null

C 20 -> 30 -> 40 -> null

D 40 -> null

💡 Hint

Remember that dequeue removes from the front and enqueue adds at the rear. The queue uses circular indexing.

After enqueue(10), enqueue(20), enqueue(30), the queue is: 10 -> 20 -> 30 -> null

dequeue() removes 10, queue becomes: 20 -> 30 -> null

enqueue(40) adds 40 at rear: 20 -> 30 -> 40 -> null

dequeue() removes 20, queue becomes: 30 -> 40 -> null

Since the queue uses circular indexing, the front points to index 2 (30), so the print_queue outputs 30 -> 40 -> null.

❓ Predict Output

intermediate

What error occurs when enqueueing in a full queue?

Given a queue implemented with a fixed-size array of length 3, initially empty. The following operations are performed:

1. enqueue(1)
2. enqueue(2)
3. enqueue(3)
4. enqueue(4)

What happens when enqueue(4) is called?

DSA Rust

struct Queue {
    arr: [i32; 3],
    front: usize,
    rear: usize,
    size: usize,
}

impl Queue {
    fn new() -> Self {
        Queue { arr: [0; 3], front: 0, rear: 0, size: 0 }
    }

    fn enqueue(&mut self, val: i32) {
        if self.size == 3 {
            panic!("Queue is full");
        }
        self.arr[self.rear] = val;
        self.rear = (self.rear + 1) % 3;
        self.size += 1;
    }
}

fn main() {
    let mut q = Queue::new();
    q.enqueue(1);
    q.enqueue(2);
    q.enqueue(3);
    q.enqueue(4);
}

A Silently ignores the enqueue operation

B Overwrites the oldest element in the queue

C Panic with message "Queue is full"

D Causes an index out of bounds runtime error

💡 Hint

Check the condition before adding a new element to the queue.

The enqueue method checks if the queue size equals the array length (3). If full, it panics with "Queue is full". So enqueue(4) causes a panic.

🔧 Debug

advanced

Identify the bug in this dequeue implementation

Consider this dequeue method for a queue implemented with a fixed-size array and circular indexing:

fn dequeue(&mut self) -> Option {
    if self.size == 0 {
        return None;
    }
    let val = self.arr[self.front];
    self.front += 1;
    self.size -= 1;
    Some(val)
}

What is the bug in this code?

DSA Rust

fn dequeue(&mut self) -> Option<i32> {
    if self.size == 0 {
        return None;
    }
    let val = self.arr[self.front];
    self.front += 1;
    self.size -= 1;
    Some(val)
}

A front index is not wrapped around using modulo, causing out of bounds error

B size is decremented before returning value, causing wrong size count

C Returns None even when queue is not empty

D Does not remove the element from the array

💡 Hint

Remember the queue uses circular indexing for front and rear.

The front index is incremented without modulo operation, so after reaching the array end, it goes out of bounds causing runtime error.

🧠 Conceptual

advanced

Why use circular indexing in array-based queue?

Why is circular indexing used in array-based queue implementations?

A To avoid using a front pointer and only use rear pointer

B To allow the queue to dynamically resize the array

C To simplify the enqueue operation by always adding at the end of the array

D To efficiently reuse empty spaces at the start of the array after dequeues

💡 Hint

Think about what happens when elements are dequeued from the front.

Without circular indexing, after dequeuing elements, the front moves forward and the space at the start of the array is wasted. Circular indexing allows the rear to wrap around and reuse that space.

❓ Predict Output

expert

What is the output of this sequence of operations on a circular queue?

Given a circular queue of size 4, initially empty, perform these operations:

1. enqueue(5)
2. enqueue(10)
3. enqueue(15)
4. dequeue()
5. enqueue(20)
6. enqueue(25)
7. dequeue()
8. enqueue(30)

What is the final printed state of the queue?

DSA Rust

struct Queue {
    arr: [i32; 4],
    front: usize,
    rear: usize,
    size: usize,
}

impl Queue {
    fn new() -> Self {
        Queue { arr: [0; 4], front: 0, rear: 0, size: 0 }
    }

    fn enqueue(&mut self, val: i32) {
        if self.size == 4 { return; }
        self.arr[self.rear] = val;
        self.rear = (self.rear + 1) % 4;
        self.size += 1;
    }

    fn dequeue(&mut self) -> Option<i32> {
        if self.size == 0 { return None; }
        let val = self.arr[self.front];
        self.front = (self.front + 1) % 4;
        self.size -= 1;
        Some(val)
    }

    fn print_queue(&self) {
        let mut i = self.front;
        let mut count = self.size;
        while count > 0 {
            print!("{} -> ", self.arr[i]);
            i = (i + 1) % 4;
            count -= 1;
        }
        print!("null\n");
    }
}

fn main() {
    let mut q = Queue::new();
    q.enqueue(5);
    q.enqueue(10);
    q.enqueue(15);
    q.dequeue();
    q.enqueue(20);
    q.enqueue(25);
    q.dequeue();
    q.enqueue(30);
    q.print_queue();
}

A 15 -> 20 -> 25 -> 30 -> null

B 20 -> 25 -> 30 -> null

C 5 -> 10 -> 15 -> 20 -> null

D 10 -> 15 -> 20 -> 25 -> null

💡 Hint

Track front and rear indices carefully after each operation with modulo wrapping.

Operations step-by-step:

• enqueue(5): queue = 5
• enqueue(10): queue = 5,10
• enqueue(15): queue = 5,10,15
• dequeue(): removes 5, queue = 10,15
• enqueue(20): queue = 10,15,20
• enqueue(25): queue = 10,15,20,25 (full)
• dequeue(): removes 10, queue = 15,20,25
• enqueue(30): queue = 15,20,25,30 (full)

Final queue elements in order: 15 -> 20 -> 25 -> 30 -> null

Practice

1. What is the main characteristic of a queue implemented using an array?

easy

A. It follows Last-In-First-Out (LIFO) order

B. It follows First-In-First-Out (FIFO) order

C. It allows random access to elements

D. It stores elements in sorted order

Solution

1. Step 1: Understand queue behavior

   A queue adds elements at the rear and removes from the front, so the first element added is the first removed.

2. Step 2: Compare with options

   This behavior matches FIFO, not LIFO or random access or sorting.

3. Final Answer:

   It follows First-In-First-Out (FIFO) order -> Option B

4. Quick Check:

   Queue = FIFO [OK]

Hint: Remember queue = first in, first out [OK]

Common Mistakes:

• Confusing queue with stack (LIFO)
• Thinking queue allows random access
• Assuming queue sorts elements

2. Which of the following is the correct Rust syntax to declare a fixed-size array of 5 integers for queue storage?

easy

A. let queue: [i32; 5] = [0; 5];

B. let queue = Vec<i32>::new(5);

C. let queue: [i32] = [0, 0, 0, 0, 0];

D. let queue = [5]int{0};

Solution

1. Step 1: Identify Rust array syntax

   In Rust, fixed-size arrays are declared as [type; size], and can be initialized with a repeated value like [0; 5].

2. Step 2: Check options

   let queue: [i32; 5] = [0; 5]; matches this syntax. let queue = Vec<i32>::new(5); uses Vec but with wrong new() usage. let queue: [i32] = [0, 0, 0, 0, 0]; misses size in type. let queue = [5]int{0}; is invalid Rust syntax.

3. Final Answer:

   let queue: [i32; 5] = [0; 5]; -> Option A

4. Quick Check:

   Rust array syntax = [type; size] [OK]

Hint: Rust arrays use [type; size] syntax [OK]

Common Mistakes:

• Using Vec::new with size argument
• Missing size in array type
• Using non-Rust syntax like option D

3. Consider this Rust code snippet for a queue using an array:

let mut queue = [0; 3];
let mut front = 0;
let mut rear = 0;

// Enqueue 10
queue[rear] = 10;
rear += 1;

// Enqueue 20
queue[rear] = 20;
rear += 1;

// Dequeue
front += 1;

// Enqueue 30
queue[rear] = 30;
rear += 1;

println!("{:?}", &queue);

What is the printed output?

medium

A. [10, 0, 30]

B. [0, 20, 30]

C. [20, 30, 0]

D. [10, 20, 30]

Solution

1. Step 1: Trace enqueue and dequeue operations

   Initially queue = [0,0,0], front=0, rear=0. Enqueue 10: queue[0]=10, rear=1 Enqueue 20: queue[1]=20, rear=2 Dequeue: front=1 (10 is logically removed but still in array) Enqueue 30: queue[2]=30, rear=3

2. Step 2: Check final queue array

   Array is [10, 20, 30]. Dequeue only moves front pointer, does not clear value.

3. Final Answer:

   [10, 20, 30] -> Option D

4. Quick Check:

   Array stores all enqueued values [OK]

Hint: Dequeue moves front pointer, array values stay [OK]

Common Mistakes:

• Assuming dequeue clears array slot
• Mixing front and rear indexes
• Confusing array content with logical queue content

4. Given this Rust queue code snippet, what is the error?

let mut queue = [0; 3];
let mut front = 0;
let mut rear = 0;

// Enqueue 10
queue[rear] = 10;
rear += 1;

// Enqueue 20
queue[rear] = 20;
rear += 1;

// Enqueue 30
queue[rear] = 30;
rear += 1;

// Enqueue 40
queue[rear] = 40;
rear += 1;

medium

A. Queue does not allow duplicate values

B. front pointer not updated after enqueue

C. Index out of bounds error when enqueueing 40

D. rear pointer should decrement after enqueue

Solution

1. Step 1: Check array size and rear increments

   Array size is 3, rear starts at 0 and increments after each enqueue. After enqueue 30, rear=3.

2. Step 2: Enqueue 40 tries to access queue[3]

   Index 3 is out of bounds for array of size 3, causing runtime error.

3. Final Answer:

   Index out of bounds error when enqueueing 40 -> Option C

4. Quick Check:

   Array size limit exceeded = error [OK]

Hint: Check array size before enqueue to avoid overflow [OK]

Common Mistakes:

• Ignoring array size limit
• Not checking rear before enqueue
• Misunderstanding pointer roles

5. You want to implement a circular queue using an array of size 4 in Rust. Initially, front = 0 and rear = 0. After these operations:

enqueue(5)
enqueue(10)
enqueue(15)
dequeue()
enqueue(20)
dequeue()

What are the values of front and rear pointers, and the queue array content?

hard

A. front = 2, rear = 0, queue = [5, 10, 15, 20]

B. front = 2, rear = 1, queue = [20, 10, 15, 0]

C. front = 1, rear = 3, queue = [5, 10, 15, 20]

D. front = 2, rear = 3, queue = [5, 10, 15, 20]

Solution

1. Step 1: Trace each operation with circular logic

   Array size = 4, front=0, rear=0 initially. - enqueue(5): queue[0]=5, rear=(0+1)%4=1 - enqueue(10): queue[1]=10, rear=2 - enqueue(15): queue[2]=15, rear=3 - dequeue(): front=(0+1)%4=1 - enqueue(20): queue[3]=20, rear=(3+1)%4=0 - dequeue(): front=(1+1)%4=2

2. Step 2: Final pointers and array

   front=2, rear=0, queue = [5, 10, 15, 20]. Dequeue only moves front pointer, does not clear array values.

3. Final Answer:

   front = 2, rear = 0, queue = [5, 10, 15, 20] -> Option A

4. Quick Check:

   Circular queue pointers wrap with modulo [OK]

Hint: Use modulo for circular pointer updates [OK]

Common Mistakes:

• Not using modulo for wrap-around
• Confusing front and rear updates
• Assuming dequeue clears array values