RubyDev - The Home for Ruby Developers

Queue & Stack Patterns

Queues and stacks are fundamental data structures that follow specific access patterns. Queues use FIFO (First In, First Out) while stacks use LIFO (Last In, First Out). Ruby provides built-in Queue class and you can implement stacks using arrays.

Queue (FIFO) - First In, First Out

Queue: A queue follows FIFO (First In, First Out) principle. Elements are added to the rear and removed from the front. Perfect for task processing, breadth-first search, and maintaining order.

Ruby's Built-in Queue Class

# Thread-safe queue operations
require
'thread'

queue = Queue.new

# Adding elements (enqueue)
queue << "first"
queue.push("second")
queue.enq("third")

# Removing elements (dequeue)
puts
queue.pop
# "first" (FIFO)
puts
queue.deq
# "second"
puts
queue.shift
# "third"

# Queue properties
puts
queue.empty?
# true
puts
queue.size
# 0

Array-based Queue Implementation

# Simple queue using array
class
SimpleQueue
  def initialize
    @items = []
  end
  
  def enqueue(item)
    @items << item
  end
  
  def dequeue
    @items.shift
  end
  
  def empty?
    @items.empty?
  end
  
  def size
    @items.size
  end
  
  def peek
    @items.first
  end
end

Stack (LIFO) - Last In, First Out

Stack: A stack follows LIFO (Last In, First Out) principle. Elements are added and removed from the same end (top). Perfect for function calls, undo operations, and depth-first search.

Array-based Stack Implementation

# Stack using array (push/pop from end)
stack = []

# Adding elements (push)
stack.push("first")
stack << "second"
stack.push("third")

# Removing elements (pop)
puts
stack.pop
# "third" (LIFO)
puts
stack.pop
# "second"
puts
stack.pop
# "first"

# Stack properties
puts
stack.empty?
# true
puts
stack.size
# 0

Custom Stack Class

# Custom stack class
class
Stack
  def initialize
    @items = []
  end
  
  def push(item)
    @items << item
  end
  
  def pop
    @items.pop
  end
  
  def peek
    @items.last
  end
  
  def empty?
    @items.empty?
  end
  
  def size
    @items.size
  end
end

Practical Applications

Queue Applications

# Task processing queue
class
TaskProcessor
  def initialize
    @queue = []
  end
  
  def add_task(task)
    @queue << task
    puts "Added task: #{task}"
  end
  
  def process_next
    return nil if @queue.empty?
    task = @queue.shift
    puts "Processing: #{task}"
    task
  end
  
  def queue_size
    @queue.size
  end
end

processor = TaskProcessor.new
processor.add_task("Send email")
processor.add_task("Generate report")
processor.add_task("Backup database")

processor.process_next
# "Send email"
processor.process_next
# "Generate report"

Stack Applications

# Undo/Redo functionality
class
UndoManager
  def initialize
    @undo_stack = []
    @redo_stack = []
  end
  
  def do_action(action)
    @undo_stack.push(action)
    @redo_stack.clear
    puts "Did: #{action}"
  end
  
  def undo
    return nil if @undo_stack.empty?
    action = @undo_stack.pop
    @redo_stack.push(action)
    puts "Undid: #{action}"
    action
  end
  
  def redo
    return nil if @redo_stack.empty?
    action = @redo_stack.pop
    @undo_stack.push(action)
    puts "Redid: #{action}"
    action
  end
end

Interactive Practice: Queue & Stack Patterns

Practice Time: Try these queue and stack examples and experiment with different FIFO/LIFO patterns. Understanding these data structures will make you a more effective Ruby programmer.

Interactive Code Runner

Ruby Code Editor

# Try these comprehensive queue and stack examples!
require 'thread'

# 1. Ruby's built-in Queue (thread-safe)
queue = Queue.new

# Adding elements (enqueue)
queue << "first"
queue.push("second")
queue.enq("third")

puts "Queue operations (FIFO):"
puts "Popped: #{queue.pop}"  # "first"
puts "Popped: #{queue.pop}"  # "second"
puts "Popped: #{queue.pop}"  # "third"
puts "Empty? #{queue.empty?}"

# 2. Array-based queue implementation
class SimpleQueue
  def initialize
    @items = []
  end
  
  def enqueue(item)
    @items << item
  end
  
  def dequeue
    @items.shift
  end
  
  def empty?
    @items.empty?
  end
  
  def size
    @items.size
  end
  
  def peek
    @items.first
  end
end

queue = SimpleQueue.new
queue.enqueue("task1")
queue.enqueue("task2")
queue.enqueue("task3")

puts "\nSimple Queue (FIFO):"
puts "Size: #{queue.size}"
puts "Peek: #{queue.peek}"
puts "Dequeued: #{queue.dequeue}"
puts "Dequeued: #{queue.dequeue}"
puts "Dequeued: #{queue.dequeue}"
puts "Empty? #{queue.empty?}"

# 3. Array-based stack (LIFO)
stack = []

# Adding elements (push)
stack.push("first")
stack << "second"
stack.push("third")

puts "\nStack operations (LIFO):"
puts "Stack: #{stack}"
puts "Popped: #{stack.pop}"  # "third"
puts "Popped: #{stack.pop}"  # "second"
puts "Popped: #{stack.pop}"  # "first"
puts "Empty? #{stack.empty?}"

# 4. Custom stack class
class Stack
  def initialize
    @items = []
  end
  
  def push(item)
    @items << item
  end
  
  def pop
    @items.pop
  end
  
  def peek
    @items.last
  end
  
  def empty?
    @items.empty?
  end
  
  def size
    @items.size
  end
end

stack = Stack.new
stack.push("item1")
stack.push("item2")
stack.push("item3")

puts "\nCustom Stack (LIFO):"
puts "Size: #{stack.size}"
puts "Peek: #{stack.peek}"
puts "Popped: #{stack.pop}"
puts "Popped: #{stack.pop}"
puts "Popped: #{stack.pop}"
puts "Empty? #{stack.empty?}"

# 5. Task processing queue
class TaskProcessor
  def initialize
    @queue = []
  end
  
  def add_task(task)
    @queue << task
    puts "Added task: #{task}"
  end
  
  def process_next
    return nil if @queue.empty?
    task = @queue.shift
    puts "Processing: #{task}"
    task
  end
  
  def queue_size
    @queue.size
  end
end

processor = TaskProcessor.new
processor.add_task("Send email")
processor.add_task("Generate report")
processor.add_task("Backup database")

puts "\nTask Processing (FIFO):"
puts "Queue size: #{processor.queue_size}"
processor.process_next
processor.process_next
processor.process_next
puts "Queue size after processing: #{processor.queue_size}"

# 6. Undo/Redo functionality
class UndoManager
  def initialize
    @undo_stack = []
    @redo_stack = []
  end
  
  def do_action(action)
    @undo_stack.push(action)
    @redo_stack.clear
    puts "Did: #{action}"
  end
  
  def undo
    return nil if @undo_stack.empty?
    action = @undo_stack.pop
    @redo_stack.push(action)
    puts "Undid: #{action}"
    action
  end
  
  def redo
    return nil if @redo_stack.empty?
    action = @redo_stack.pop
    @undo_stack.push(action)
    puts "Redid: #{action}"
    action
  end
end

undo_manager = UndoManager.new
undo_manager.do_action("Type text")
undo_manager.do_action("Bold text")
undo_manager.do_action("Italicize text")

puts "\nUndo/Redo (LIFO):"
undo_manager.undo
undo_manager.undo
undo_manager.redo
undo_manager.redo

# 7. Expression evaluation with stack
class ExpressionEvaluator
  def initialize
    @stack = []
  end
  
  def evaluate_postfix(expression)
    tokens = expression.split
    
    tokens.each do |token|
      if token.match?(/\d+/)
        @stack.push(token.to_i)
      else
        b = @stack.pop
        a = @stack.pop
        result = case token
                when '+' then a + b
                when '-' then a - b
                when '*' then a * b
                when '/' then a / b
                end
        @stack.push(result)
      end
    end
    
    @stack.pop
  end
end

evaluator = ExpressionEvaluator.new
result = evaluator.evaluate_postfix("3 4 + 2 * 7 /")
puts "\nPostfix evaluation: 3 4 + 2 * 7 / = #{result}"

# Add your own queue and stack experiments below!

Output will appear here when you run the code...

Queue & Stack Best Practices

✅ Do This

Use Queue for thread-safe operations
Use arrays for simple queue/stack implementations
Implement proper error handling for empty structures
Use queues for task processing and BFS
Use stacks for undo/redo and DFS

❌ Avoid This

Using wrong data structure for the problem
Not handling empty queue/stack cases
Using Queue when thread safety isn't needed
Forgetting FIFO vs LIFO principles
Not considering performance implications

Queue & Stack Mastery Checklist

Queue (FIFO): Understand First In, First Out principle
Stack (LIFO): Understand Last In, First Out principle
Built-in Queue: Use Ruby's thread-safe Queue class
Array Implementation: Implement queues and stacks with arrays
Operations: Master enqueue/dequeue and push/pop operations
Applications: Apply to task processing, undo/redo, and algorithms
Error Handling: Handle empty queue/stack cases properly
Performance: Understand time and space complexity

Next Steps: Practice with queues for task processing and stacks for undo operations. These fundamental data structures are essential for many algorithms and real-world applications!

Queue & Stack Patterns

Queue & Stack Patterns

Queue (FIFO) - First In, First Out

Ruby's Built-in Queue Class

Array-based Queue Implementation

Stack (LIFO) - Last In, First Out

Array-based Stack Implementation

Custom Stack Class

Practical Applications

Queue Applications

Stack Applications

Interactive Practice: Queue & Stack Patterns

Interactive Code Runner

Ruby Code Editor

Queue & Stack Best Practices

✅ Do This

❌ Avoid This

Queue & Stack Mastery Checklist

Quick Navigation

Related Topics

Video Tutorial

Ruby Language

Rails Framework

Production Ready

Queue & Stack Patterns

Queue & Stack Patterns

Queue (FIFO) - First In, First Out

Ruby's Built-in Queue Class

Array-based Queue Implementation

Stack (LIFO) - Last In, First Out

Array-based Stack Implementation

Custom Stack Class

Practical Applications

Queue Applications

Stack Applications

Interactive Practice: Queue & Stack Patterns

Interactive Code Runner

Ruby Code Editor

Queue & Stack Best Practices

✅ Do This

❌ Avoid This

Queue & Stack Mastery Checklist

Quick Navigation

Related Topics

Video Tutorial