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

Queue vs Stack: When to Use Which

📖 Scenario: Imagine you are managing a small bakery. Customers come in and place orders. Some orders need to be handled in the order they arrive (like a queue), while others need to be handled in reverse order (like a stack) because they are special requests that must be completed last.

🎯 Goal: You will create two simple data structures: a queue and a stack using slices in Go. Then, you will add orders to each and print the orders in the correct sequence to understand when to use a queue or a stack.

📋 What You'll Learn

Create a slice called queue with orders: "Order1", "Order2", "Order3"

Create a slice called stack with orders: "Special1", "Special2", "Special3"

Add a variable queueLength to store the length of the queue

Add a variable stackLength to store the length of the stack

Use a for loop with index i to print all orders in the queue in the order they were added

Use a for loop with index i to print all orders in the stack in reverse order (last added first)

💡 Why This Matters

🌍 Real World

Queues are used in real life when people wait in line, like at a bakery or bank. Stacks are used when you need to undo actions or manage tasks that must be done in reverse order.

💼 Career

Understanding queues and stacks is important for software developers to manage data flow, task scheduling, and undo features in applications.

1

Create the initial orders for queue and stack

Create a slice called queue with these exact orders: "Order1", "Order2", "Order3". Also create a slice called stack with these exact orders: "Special1", "Special2", "Special3".

DSA Go

# Your code here

Hint

Use Go slice syntax to create queue and stack with the exact orders.

2

Add variables to store lengths of queue and stack

Add a variable called queueLength that stores the length of queue. Also add a variable called stackLength that stores the length of stack.

DSA Go

package main

import "fmt"

func main() {
    queue := []string{"Order1", "Order2", "Order3"}
    stack := []string{"Special1", "Special2", "Special3"}
    // Your code here
}

Hint

Use the len() function to get the length of slices.

3

Print orders in queue and stack using loops

Use a for loop with index i from 0 to queueLength to print each order in queue in the order they were added. Then use a for loop with index i from stackLength - 1 down to 0 to print each order in stack in reverse order.

DSA Go

package main

import "fmt"

func main() {
    queue := []string{"Order1", "Order2", "Order3"}
    stack := []string{"Special1", "Special2", "Special3"}
    queueLength := len(queue)
    stackLength := len(stack)
    // Your code here
}

Hint

Use two separate for loops: one counting up for the queue, one counting down for the stack.

4

Print the final output showing queue and stack orders

Print the orders from queue first, then print the orders from stack as shown in the loops. The output should list all queue orders in order, then all stack orders in reverse order.

DSA Go

package main

import "fmt"

func main() {
    queue := []string{"Order1", "Order2", "Order3"}
    stack := []string{"Special1", "Special2", "Special3"}
    queueLength := len(queue)
    stackLength := len(stack)

    for i := 0; i = 0; i-- {
        fmt.Println(stack[i])
    }
    // Your code here
}

Hint

Run the program to see the orders printed in the correct sequence.

Practice

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

easy

A. Queue, because it processes items in First-In-First-Out order

B. Stack, because it processes items in Last-In-First-Out order

C. Array, because it allows random access

D. Tree, because it organizes data hierarchically

Solution

1. Step 1: Understand the order requirement

   Processing items in the exact order they arrive means First-In-First-Out (FIFO).

2. Step 2: Match data structure to FIFO

   Queue follows FIFO, so it fits the requirement perfectly.

3. Final Answer:

   Queue, because it processes items in First-In-First-Out order -> Option A

4. Quick Check:

   FIFO = Queue [OK]

Hint: FIFO means use Queue, like a line at a store [OK]

Common Mistakes:

• Confusing FIFO with LIFO
• Choosing Stack for order-sensitive tasks
• Thinking arrays maintain insertion order automatically

2. Which of the following is the correct way to push an element onto a stack in Go using a slice named stack?

easy

A. stack = append(element, stack...)

B. stack = stack[:len(stack)-1]

C. stack = stack + element

D. stack = append(stack, element)

Solution

1. Step 1: Recall how to add elements to a slice

   In Go, append(slice, value) adds value to the end of slice.

2. Step 2: Identify correct push operation

   Pushing onto a stack means adding to the top, which is the end of the slice, so stack = append(stack, element) is correct.

3. Final Answer:

   stack = append(stack, element) -> Option D

4. Quick Check:

   Push = append to slice end [OK]

Hint: Use append to add on top of stack slice [OK]

Common Mistakes:

• Using slicing to add elements instead of append
• Trying to add element at the front incorrectly
• Using + operator which is invalid for slices

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

queue := []int{1, 2, 3}
// Dequeue operation
queue = queue[1:]
fmt.Println(queue)

medium

A. [2 3]

B. []

C. [3]

D. [1 2 3]

Solution

1. Step 1: Understand the dequeue operation

   Dequeue removes the first element, so slicing from index 1 removes the first element.

2. Step 2: Apply slicing to queue

   Original queue is [1 2 3], after queue = queue[1:], queue becomes [2 3].

3. Final Answer:

   [2 3] -> Option A

4. Quick Check:

   queue[1:] removes first element [OK]

Hint: queue = queue[1:] removes front element [OK]

Common Mistakes:

• Thinking queue[1:] removes last element
• Confusing slice syntax with pop operation
• Expecting original queue unchanged

4. The following Go code intends to pop an element from a stack implemented as a slice. What is the error?

stack := []int{10, 20, 30}
popped := stack[len(stack)]
stack = stack[:len(stack)-1]
fmt.Println(popped, stack)

medium

A. Syntax error due to missing parentheses

B. Index out of range error when accessing stack[len(stack)]

C. Popped element is always zero

D. Stack slice is not updated correctly

Solution

1. Step 1: Check index used for popping

   Indexing in Go slices is zero-based, so last element is at len(stack)-1, not len(stack).

2. Step 2: Identify error cause

   Accessing stack[len(stack)] causes index out of range error because it is beyond last index.

3. Final Answer:

   Index out of range error when accessing stack[len(stack)] -> Option B

4. Quick Check:

   Last index = len(stack)-1, not len(stack) [OK]

Hint: Last element index is len(slice)-1, not len(slice) [OK]

Common Mistakes:

• Using len(slice) as index instead of len(slice)-1
• Not updating slice after pop
• Confusing pop with dequeue operation

5. You need to design a system that tracks the most recent 5 user actions to allow undo functionality. Which data structure is best and why?

hard

A. Array, because it allows random access to any action

B. Queue, because it keeps actions in order and removes oldest first

C. Stack, because it allows undo by removing the most recent action first

D. Linked list, because it allows fast insertion anywhere

Solution

1. Step 1: Understand undo functionality

   Undo removes the most recent action first, which is Last-In-First-Out (LIFO) behavior.

2. Step 2: Match data structure to LIFO

   Stack follows LIFO, so it is best to track recent actions and undo them in reverse order.

3. Final Answer:

   Stack, because it allows undo by removing the most recent action first -> Option C

4. Quick Check:

   Undo = LIFO = Stack [OK]

Hint: Undo needs LIFO, so use Stack [OK]

Common Mistakes:

• Choosing Queue which removes oldest first
• Thinking array random access helps undo
• Ignoring order of undo operations