Queues

import java.util.LinkedList;
import java.util.NoSuchElementException;

/**
 * A Queue implementation using LinkedList
 * Demonstrates FIFO (First-In-First-Out) principle
 */
public class Queue<T> {
    private LinkedList<T> items;
    
    /**
     * Constructor to create an empty queue
     */
    public Queue() {
        this.items = new LinkedList<>();
    }
    
    /**
     * Add an item to the rear of the queue
     * Like a person joining the back of a line
     * 
     * Time Complexity: O(1)
     * Space Complexity: O(1)
     */
    public void enqueue(T item) {
        items.addLast(item);
        System.out.println("Enqueued " + item + ". Queue: " + items);
    }
    
    /**
     * Remove and return the front item from the queue
     * Like the first person in line being served
     * 
     * Time Complexity: O(1)
     * Space Complexity: O(1)
     * 
     * @throws NoSuchElementException if queue is empty
     */
    public T dequeue() {
        if (isEmpty()) {
            throw new NoSuchElementException("dequeue from empty queue");
        }
        
        T item = items.removeFirst();
        System.out.println("Dequeued " + item + ". Queue: " + items);
        return item;
    }
    
    /**
     * Return the front item without removing it
     * Like looking at who's first in line
     * 
     * Time Complexity: O(1)
     * Space Complexity: O(1)
     * 
     * @throws NoSuchElementException if queue is empty
     */
    public T peekFront() {
        if (isEmpty()) {
            throw new NoSuchElementException("peek at empty queue");
        }
        
        return items.getFirst();
    }
    
    /**
     * Return the rear item without removing it
     * Like looking at who's last in line
     * 
     * Time Complexity: O(1)
     * Space Complexity: O(1)
     */
    public T peekRear() {
        if (isEmpty()) {
            throw new NoSuchElementException("peek at empty queue");
        }
        
        return items.getLast();
    }
    
    /**
     * Check if the queue is empty
     */
    public boolean isEmpty() {
        return items.isEmpty();
    }
    
    /**
     * Return the number of items in the queue
     */
    public int size() {
        return items.size();
    }
    
    /**
     * Display queue contents from front to rear
     */
    public String display() {
        if (isEmpty()) {
            return "Empty Queue";
        }
        return "Queue (front → rear): " + items.toString();
    }
    
    /**
     * Demonstrate how queue follows FIFO principle
     */
    public static void demonstrateFIFO() {
        System.out.println("=== Demonstrating FIFO Principle ===");
        System.out.println("Think of this like a line at a store...");
        
        Queue<String> queue = new Queue<>();
        
        // Enqueue items (people joining the line)
        System.out.println("\nPeople joining the line:");
        queue.enqueue("Alice (first)");
        queue.enqueue("Bob (second)");
        queue.enqueue("Charlie (third)");
        
        System.out.println("\nFront person: " + queue.peekFront());
        System.out.println("Rear person: " + queue.peekRear());
        System.out.println("Queue size: " + queue.size());
        
        // Dequeue items (people being served)
        System.out.println("\nServing people (FIFO order):");
        while (!queue.isEmpty()) {
            String person = queue.dequeue();
            System.out.println("Served: " + person);
        }
        
        System.out.println("\nQueue is now empty: " + queue.isEmpty());
    }
    
    /**
     * Simulate task scheduling using queue
     */
    public static void taskSchedulingDemo() {
        System.out.println("\n=== Task Scheduling Demo ===");
        Queue<String> taskQueue = new Queue<>();
        
        // Add tasks to queue
        System.out.println("Adding tasks to queue:");
        taskQueue.enqueue("Process Email");
        taskQueue.enqueue("Update Database");
        taskQueue.enqueue("Send Notifications");
        taskQueue.enqueue("Generate Report");
        
        // Process tasks in FIFO order
        System.out.println("\nProcessing tasks in order:");
        while (!taskQueue.isEmpty()) {
            String task = taskQueue.dequeue();
            System.out.println("Executing: " + task);
            
            // Simulate processing time
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
        
        System.out.println("\nAll tasks completed!");
    }
    
    public static void main(String[] args) {
        // Basic queue operations
        demonstrateFIFO();
        
        // Practical application
        taskSchedulingDemo();
    }
}

#include <iostream>
#include <queue>
#include <string>
#include <vector>
#include <stdexcept>
using namespace std;

// Custom Queue implementation using vector
template<typename T>
class Queue {
private:
    vector<T> items;
    int frontIndex;
    int rearIndex;
    int count;
    
public:
    /**
     * Constructor to create an empty queue
     */
    Queue() : frontIndex(0), rearIndex(-1), count(0) {
        items.resize(100); // Initial capacity
    }
    
    /**
     * Add an item to the rear of the queue
     * Like a person joining the back of a line
     * 
     * Time Complexity: O(1)
     * Space Complexity: O(1)
     */
    void enqueue(const T& item) {
        if (count >= items.size()) {
            items.resize(items.size() * 2); // Dynamic resize
        }
        
        rearIndex = (rearIndex + 1) % items.size();
        items[rearIndex] = item;
        count++;
        
        cout << "Enqueued " << item << ". Queue: ";
        display();
    }
    
    /**
     * Remove and return the front item from the queue
     * Like the first person in line being served
     * 
     * Time Complexity: O(1)
     * Space Complexity: O(1)
     * 
     * @throws runtime_error if queue is empty
     */
    T dequeue() {
        if (isEmpty()) {
            throw runtime_error("dequeue from empty queue");
        }
        
        T item = items[frontIndex];
        frontIndex = (frontIndex + 1) % items.size();
        count--;
        
        cout << "Dequeued " << item << ". Queue: ";
        display();
        return item;
    }
    
    /**
     * Return the front item without removing it
     * Like looking at who's first in line
     * 
     * Time Complexity: O(1)
     * Space Complexity: O(1)
     */
    T peekFront() const {
        if (isEmpty()) {
            throw runtime_error("peek at empty queue");
        }
        
        return items[frontIndex];
    }
    
    /**
     * Return the rear item without removing it
     * Like looking at who's last in line
     * 
     * Time Complexity: O(1)
     * Space Complexity: O(1)
     */
    T peekRear() const {
        if (isEmpty()) {
            throw runtime_error("peek at empty queue");
        }
        
        return items[rearIndex];
    }
    
    /**
     * Check if the queue is empty
     */
    bool isEmpty() const {
        return count == 0;
    }
    
    /**
     * Return the number of items in the queue
     */
    int size() const {
        return count;
    }
    
    /**
     * Display queue contents from front to rear
     */
    void display() const {
        if (isEmpty()) {
            cout << "Empty Queue" << endl;
            return;
        }
        
        cout << "[";
        for (int i = 0; i < count; i++) {
            int index = (frontIndex + i) % items.size();
            cout << items[index];
            if (i < count - 1) cout << ", ";
        }
        cout << "] (front → rear)" << endl;
    }
};

/**
 * Demonstrate how queue follows FIFO principle
 */
void demonstrateFIFO() {
    cout << "=== Demonstrating FIFO Principle ===" << endl;
    cout << "Think of this like a line at a store..." << endl;
    
    Queue<string> queue;
    
    // Enqueue items (people joining the line)
    cout << "\nPeople joining the line:" << endl;
    queue.enqueue("Alice (first)");
    queue.enqueue("Bob (second)");
    queue.enqueue("Charlie (third)");
    
    cout << "\nFront person: " << queue.peekFront() << endl;
    cout << "Rear person: " << queue.peekRear() << endl;
    cout << "Queue size: " << queue.size() << endl;
    
    // Dequeue items (people being served)
    cout << "\nServing people (FIFO order):" << endl;
    while (!queue.isEmpty()) {
        string person = queue.dequeue();
        cout << "Served: " << person << endl;
    }
    
    cout << "\nQueue is now empty: " << 
            (queue.isEmpty() ? "true" : "false") << endl;
}

/**
 * Simulate printer queue using standard queue
 */
void printerQueueDemo() {
    cout << "\n=== Printer Queue Demo ===" << endl;
    queue<string> printerQueue;
    
    // Add print jobs to queue
    cout << "Adding print jobs to queue:" << endl;
    printerQueue.push("Document1.pdf");
    printerQueue.push("Photo.jpg");
    printerQueue.push("Spreadsheet.xlsx");
    printerQueue.push("Presentation.pptx");
    
    cout << "Queue size: " << printerQueue.size() << endl;
    
    // Process print jobs in FIFO order
    cout << "\nProcessing print jobs in order:" << endl;
    while (!printerQueue.empty()) {
        string job = printerQueue.front();
        printerQueue.pop();
        cout << "Printing: " << job << endl;
    }
    
    cout << "\nAll print jobs completed!" << endl;
}

int main() {
    // Basic queue operations
    demonstrateFIFO();
    
    // Practical application
    printerQueueDemo();
    
    return 0;
}