Priority Queue in C++

// Required headers
#include <iostream>   // For input and output
#include <queue>      // For std::priority_queue
#include <vector>     // For using custom containers if needed

int main() {
    // Create a max heap (default behavior of std::priority_queue)
    std::priority_queue<int> max_pq;

    // Insert elements into the priority queue
    max_pq.push(10); // Add 10; internally arranged to maintain heap property
    max_pq.push(30); // Add 30; becomes the top element (largest so far)
    max_pq.push(20); // Add 20; heap reorganizes to keep the largest element at the top

    // Output the elements in order of priority
    std::cout << "Max Priority Queue elements:\n";
    while (!max_pq.empty()) {
        // Access the top element (largest in the max-heap)
        std::cout << max_pq.top() << " ";
        max_pq.pop(); // Remove the top element and reorganize the heap
    }
    std::cout << "\n";

    // Create a min heap using greater comparator
    std::priority_queue<int, std::vector<int>, std::greater<>> min_pq;

    // Insert elements into the min heap
    min_pq.push(10); // Add 10; smallest so far
    min_pq.push(30); // Add 30; heap maintains smallest (10) at the top
    min_pq.push(20); // Add 20; heap adjusts to keep 10 at the top

    // Output the elements in ascending order of priority
    std::cout << "Min Priority Queue elements:\n";
    while (!min_pq.empty()) {
        std::cout << min_pq.top() << " "; // Access the smallest element
        min_pq.pop(); // Remove the smallest element and reorganize the heap
    }

    return 0;
}

#include <iostream>   // For standard input and output
#include <queue>      // For std::priority_queue
#include <string>     // For std::string
#include <vector>     // For the custom container

// Custom task structure
struct Task {
    std::string name;  // Name of the task
    int priority;      // Priority of the task

    // Custom comparison operator
    bool operator<(const Task& other) const {
        // Compare by priority first, then lexicographically by name
        if (priority == other.priority) {
            return name < other.name; // Name comparison if priorities are equal
        }
        return priority < other.priority; // Compare by priority otherwise
    }
};

// Custom comparator for the priority queue
struct TaskCompare {
    bool operator()(const Task& a, const Task& b) const {
        return a.priority < b.priority; // Higher priority value = higher precedence
    }
};

int main() {
    // Create a priority queue for Task objects
    std::priority_queue<Task, std::vector<Task>, TaskCompare> task_queue;

    // Add some tasks to the priority queue
    task_queue.push({"Write docs", 2}); // Task with priority 2
    task_queue.push({"Fix bug", 3});   // Task with priority 3
    task_queue.push({"Add feature", 1}); // Task with priority 1

    std::cout << "Processing tasks by priority:\n";

    // Process and print tasks in descending order of priority
    while (!task_queue.empty()) {
        const Task& top = task_queue.top(); // Get the task with the highest priority
        std::cout << "Task: " << top.name
                  << ", Priority: " << top.priority << "\n";
        task_queue.pop(); // Remove the processed task
    }

    return 0;
}

#include <iostream>
#include <queue>
#include <string_view>
#include <vector>

struct Event {
    std::string_view name;
    int timestamp;
    int priority;
};

// Using a custom comparator with explicit template arguments
int main() {
    // Define the comparator as a lambda
    auto compare = [](const Event& a, const Event& b) {
        if (a.priority != b.priority) {
            return a.priority < b.priority; // Higher priority = higher precedence
        }
        return a.timestamp > b.timestamp;  // Earlier timestamp = higher precedence
    };

    // Explicitly specify all template arguments and pass the comparator
    std::priority_queue<Event,
                       std::vector<Event>,
                       decltype(compare)> event_queue(compare);

    // Add events using list initialization
    event_queue.push({"User Login", 1000, 1});      // Priority 1
    event_queue.push({"Critical Error", 1001, 3});  // Priority 3
    event_queue.push({"Warning", 1002, 2});         // Priority 2

    std::cout << "Processing events by priority:\n";
    while (!event_queue.empty()) {
        const auto& top_event = event_queue.top();
        std::cout << "Event: " << top_event.name
                  << ", Time: " << top_event.timestamp
                  << ", Priority: " << top_event.priority << "\n";
        event_queue.pop();
    }

    return 0;
}

#include <iostream>
#include <queue>
#include <string_view>
#include <vector>

struct Event {
    std::string_view name;
    int timestamp;
    int priority;
};

struct EventCompare {
    bool operator()(const Event& a, const Event& b) const {
        if (a.priority != b.priority) {
            return a.priority < b.priority;
        }
        return a.timestamp > b.timestamp;
    }
};

int main() {
    std::priority_queue<Event,
                       std::vector<Event>,
                       EventCompare> event_queue;

    event_queue.push({"User Login", 1000, 1});
    event_queue.push({"Critical Error", 1001, 3});
    event_queue.push({"Warning", 1002, 2});

    std::cout << "Processing events by priority:\n";
    while (!event_queue.empty()) {
        const auto& top_event = event_queue.top();
        std::cout << "Event: " << top_event.name
                  << ", Time: " << top_event.timestamp
                  << ", Priority: " << top_event.priority << "\n";
        event_queue.pop();
    }

    return 0;
}

#include <iostream>
#include <queue>
#include <vector>
#include <string>

struct LargeObject {
    std::string data;

    // Constructor
    LargeObject(std::string d) : data(std::move(d)) {
        std::cout << "Constructing: " << data << "\n";
    }

    // Move Constructor
    LargeObject(LargeObject&& other) noexcept : data(std::move(other.data)) {
        std::cout << "Moving: " << data << "\n";
    }

    // Move Assignment Operator
    LargeObject& operator=(LargeObject&& other) noexcept {
        std::cout << "Move assigning: " << other.data << "\n";
        if (this != &other) {
            data = std::move(other.data);
        }
        return *this;
    }

    // Deleted Copy Constructor
    LargeObject(const LargeObject&) = delete;

    // Deleted Copy Assignment
    LargeObject& operator=(const LargeObject&) = delete;

    // Destructor
    ~LargeObject() {
        if (data.empty()) {
            std::cout << "Destroying moved-from object\n";
        } else {
            std::cout << "Destroying: " << data << "\n";
        }
    }

    // Custom Comparator - reversed for priority queue
    bool operator<(const LargeObject& other) const {
        return data.size() > other.data.size(); // Reversed comparison for max heap
    }
};

int main() {
    // Create a priority queue with proper type specification
    std::priority_queue<LargeObject> pq;

    // Use emplace to construct objects directly in the queue
    pq.emplace("Short");
    pq.emplace("A much longer string");
    pq.emplace("Medium length");

    // Process elements
    while (!pq.empty()) {
        // Access the top element (largest based on custom comparator)
        std::cout << "Top: " << pq.top().data << "\n";
        pq.pop(); // Remove the element
    }

    return 0;
}