Queue vs Stack When to Use Which in DSA C++ - Build Both Approaches

Queue vs Stack: When to Use Which

📖 Scenario: Imagine you are managing a line at a coffee shop and a pile of plates in the kitchen. You want to understand how to organize these using two different methods: a queue and a stack.

🎯 Goal: You will create a queue and a stack in C++ to see how items are added and removed differently. This will help you learn when to use a queue or a stack in real life.

📋 What You'll Learn

Create a queue of strings called coffeeLine with three customers: "Alice", "Bob", and "Charlie"

Create a stack of strings called plateStack with three plates labeled: "Plate1", "Plate2", and "Plate3"

Remove one customer from the front of the queue and one plate from the top of the stack

Print the remaining items in the queue and stack to show their order

💡 Why This Matters

🌍 Real World

Queues are used in situations like lines at stores or printers where first come, first served is important. Stacks are used in undo features, browser history, and managing tasks where the last added is handled first.

💼 Career

Understanding when to use queues or stacks helps in software development, especially in designing algorithms, managing tasks, and handling data flow efficiently.

1

Create the queue and stack with initial items

Create a std::queue<std::string> called coffeeLine and add "Alice", "Bob", and "Charlie" in that order. Also create a std::stack<std::string> called plateStack and add "Plate1", "Plate2", and "Plate3" in that order.

DSA C++

#include 
#include 
#include 
#include 

int main() {

    // Create coffeeLine queue and add "Alice", "Bob", "Charlie"
    // Create plateStack stack and add "Plate1", "Plate2", "Plate3"

    return 0;
}

Hint

Use push to add items to both the queue and the stack.

2

Remove one item from the queue and stack

Remove one customer from the front of the coffeeLine queue using pop(). Remove one plate from the top of the plateStack stack using pop().

DSA C++

#include 
#include 
#include 
#include 

int main() {
    std::queue coffeeLine;
    coffeeLine.push("Alice");
    coffeeLine.push("Bob");
    coffeeLine.push("Charlie");

    std::stack plateStack;
    plateStack.push("Plate1");
    plateStack.push("Plate2");
    plateStack.push("Plate3");

    // Remove one customer from coffeeLine
    // Remove one plate from plateStack

    return 0;
}

Hint

Use pop() to remove the front item from the queue and the top item from the stack.

3

Print remaining customers in the queue

Use a while loop to print all remaining customers in coffeeLine. Use front() to get the customer name and pop() to remove them after printing.

DSA C++

#include 
#include 
#include 
#include 

int main() {
    std::queue coffeeLine;
    coffeeLine.push("Alice");
    coffeeLine.push("Bob");
    coffeeLine.push("Charlie");

    std::stack plateStack;
    plateStack.push("Plate1");
    plateStack.push("Plate2");
    plateStack.push("Plate3");

    coffeeLine.pop();
    plateStack.pop();

    // Print all remaining customers in coffeeLine

    return 0;
}

Hint

Use while (!coffeeLine.empty()) to loop until the queue is empty.

4

Print remaining plates in the stack

Use a while loop to print all remaining plates in plateStack. Use top() to get the plate name and pop() to remove them after printing.

DSA C++

#include 
#include 
#include 
#include 

int main() {
    std::queue coffeeLine;
    coffeeLine.push("Alice");
    coffeeLine.push("Bob");
    coffeeLine.push("Charlie");

    std::stack plateStack;
    plateStack.push("Plate1");
    plateStack.push("Plate2");
    plateStack.push("Plate3");

    coffeeLine.pop();
    plateStack.pop();

    std::cout << "Customers in coffeeLine: ";
    while (!coffeeLine.empty()) {
        std::cout << coffeeLine.front() << " ";
        coffeeLine.pop();
    }
    std::cout << std::endl;

    // Print all remaining plates in plateStack

    return 0;
}

Hint

Use while (!plateStack.empty()) and top() to print plates in LIFO order.

Practice

1. Which data structure should you use when you need to process elements in the exact order they arrive, like customers waiting in line?

easy

A. Graph

B. Stack

C. Tree

D. Queue

Solution

1. Step 1: Understand the order requirement

   Customers waiting in line are served in the order they arrive, which is First-In-First-Out (FIFO).

2. Step 2: Match data structure behavior

   A queue follows FIFO, so it fits this scenario perfectly.

3. Final Answer:

   Queue -> Option D

4. Quick Check:

   FIFO = Queue [OK]

Hint: Use queue for FIFO order tasks like waiting lines [OK]

Common Mistakes:

• Confusing stack (LIFO) with queue (FIFO)
• Choosing tree or graph which are not linear
• Ignoring order of processing

2. Which of the following is the correct way to push an element '5' onto a stack named myStack in C++ STL?

easy

A. myStack.push(5);

B. myStack.enqueue(5);

C. myStack.insert(5);

D. myStack.add(5);

Solution

1. Step 1: Recall stack insertion method in C++ STL

   The standard method to add an element to a stack is push().

2. Step 2: Verify the syntax

   Using myStack.push(5); correctly adds 5 to the top of the stack.

3. Final Answer:

   myStack.push(5); -> Option A

4. Quick Check:

   Stack insertion = push() [OK]

Hint: Use push() to add elements to a stack in C++ [OK]

Common Mistakes:

• Using enqueue which is for queues
• Using insert or add which are not stack methods
• Confusing stack methods with vector methods

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

#include <iostream>
#include <stack>
using namespace std;

int main() {
    stack<int> s;
    s.push(10);
    s.push(20);
    s.push(30);
    cout << s.top() << endl;
    s.pop();
    cout << s.top() << endl;
    return 0;
}

medium

A. 30\n20

B. 10\n20

C. 20\n10

D. 30\n10

Solution

1. Step 1: Trace stack operations

   Elements pushed in order: 10 (bottom), 20, 30 (top). First cout prints top: 30.

2. Step 2: Pop and print new top

   Pop removes 30, new top is 20, second cout prints 20.

3. Final Answer:

   30\n20 -> Option A

4. Quick Check:

   Stack top after push and pop = 30 then 20 [OK]

Hint: Stack top shows last pushed element, pop removes it [OK]

Common Mistakes:

• Assuming queue order instead of stack
• Printing bottom element instead of top
• Confusing pop with peek

4. The following code is intended to implement a queue using C++ STL. Identify the error:

#include <iostream>
#include <queue>
using namespace std;

int main() {
    queue<int> q;
    q.push(1);
    q.push(2);
    cout << q.top() << endl;
    return 0;
}

medium

A. queue requires pop() before push()

B. queue cannot push elements

C. queue does not have a top() method

D. queue must be declared as stack

Solution

1. Step 1: Check queue methods

   Queue uses front() to access the first element, not top().

2. Step 2: Identify the error in code

   Using q.top() causes a compile error because top() is a stack method.

3. Final Answer:

   queue does not have a top() method -> Option C

4. Quick Check:

   Queue front() not top() [OK]

Hint: Use front() for queue, top() for stack [OK]

Common Mistakes:

• Using top() with queue
• Thinking queue needs pop before push
• Confusing queue and stack declarations

5. You want to reverse the order of words in a sentence efficiently. Which data structure is best suited for this task and why?

hard

A. Queue, because it preserves original order

B. Stack, because it reverses order using LIFO

C. Queue, because it supports random access

D. Stack, because it sorts elements automatically

Solution

1. Step 1: Understand the problem requirement

   Reversing word order means last word should come first, which is Last-In-First-Out (LIFO).

2. Step 2: Choose data structure matching LIFO

   Stack follows LIFO, so pushing words then popping reverses their order efficiently.

3. Final Answer:

   Stack, because it reverses order using LIFO -> Option B

4. Quick Check:

   Reverse order = Stack (LIFO) [OK]

Hint: Use stack to reverse order with LIFO behavior [OK]

Common Mistakes:

• Choosing queue which preserves order
• Thinking stack sorts elements automatically
• Confusing random access with reversal