priority_queue有什么应用场景？

#include <queue>
#include <iostream>

struct Task {
    int priority;
    std::string name;

    // 自定义优先级比较器
    bool operator<(const Task& other) const {
        return priority < other.priority;  // 低的优先级排在后面
    }
};

void taskScheduler() {
    std::priority_queue<Task> pq;

    // 插入任务到优先队列
    pq.push({1, "Low Priority Task"});
    pq.push({3, "High Priority Task"});
    pq.push({2, "Medium Priority Task"});

    // 按优先级处理任务
    while (!pq.empty()) {
        std::cout << "Processing task: " << pq.top().name << std::endl;
        pq.pop();  // 移除优先级最高的任务
    }
}

int main() {
    taskScheduler();  // 调度任务
    return 0;
}

#include <queue>
#include <iostream>
#include <vector>
#include <tuple>

void dijkstra(const std::vector<std::vector<int>>& graph, int start) {
    int n = graph.size();
    std::vector<int> dist(n, INT_MAX);
    dist[start] = 0;

    std::priority_queue<std::tuple<int, int>, std::vector<std::tuple<int, int>>, std::greater<>> pq;
    pq.push({0, start});

    while (!pq.empty()) {
        int currentDist, node;
        std::tie(currentDist, node) = pq.top();
        pq.pop();

        for (int i = 0; i < n; ++i) {
            if (graph[node][i] != -1) {
                int newDist = currentDist + graph[node][i];
                if (newDist < dist[i]) {
                    dist[i] = newDist;
                    pq.push({dist[i], i});
                }
            }
        }
    }

    // 输出最短路径
    for (int i = 0; i < n; ++i) {
        std::cout << "Distance from " << start << " to " << i << ": " << dist[i] << std::endl;
    }
}

int main() {
    std::vector<std::vector<int>> graph = {
        {0, 7, -1, -1, -1, -1},
        {7, 0, 5, -1, -1, -1},
        {-1, 5, 0, 2, 4, -1},
        {-1, -1, 2, 0, 3, 6},
        {-1, -1, 4, 3, 0, 1},
        {-1, -1, -1, 6, 1, 0}
    };

    dijkstra(graph, 0);  // 从节点0开始计算最短路径
    return 0;
}

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

void mergeSortedArrays(const std::vector<std::vector<int>>& arrays) {
    std::priority_queue<int, std::vector<int>, std::greater<int>> pq;

    // 将所有数组的元素插入优先队列
    for (const auto& array : arrays) {
        for (int num : array) {
            pq.push(num);
        }
    }

    // 按顺序输出所有元素
    while (!pq.empty()) {
        std::cout << pq.top() << " ";
        pq.pop();
    }
    std::cout << std::endl;
}

int main() {
    std::vector<std::vector<int>> arrays = {
        {1, 3, 5},
        {2, 4, 6},
        {0, 7, 8}
    };
    mergeSortedArrays(arrays);  // 合并并输出所有元素
    return 0;
}

#include <queue>
#include <iostream>

class MedianFinder {
private:
    std::priority_queue<int> maxHeap;  // 存储较小一半元素（最大堆）
    std::priority_queue<int, std::vector<int>, std::greater<int>> minHeap;  // 存储较大一半元素（最小堆）

public:
    void addNum(int num) {
        if (maxHeap.empty() || num <= maxHeap.top()) {
            maxHeap.push(num);
        } else {
            minHeap.push(num);
        }

        // 平衡堆的大小
        if (maxHeap.size() > minHeap.size() + 1) {
            minHeap.push(maxHeap.top());
            maxHeap.pop();
        } else if (minHeap.size() > maxHeap.size()) {
            maxHeap.push(minHeap.top());
            minHeap.pop();
        }
    }

    double findMedian() {
        if (maxHeap.size() > minHeap.size()) {
            return maxHeap.top();
        }
        return (maxHeap.top() + minHeap.top()) / 2.0;
    }
};

int main() {
    MedianFinder medianFinder;
    medianFinder.addNum(1);
    medianFinder.addNum(2);
    std::cout << "Median: " << medianFinder.findMedian() << std::endl;  // 输出 1.5
    medianFinder.addNum(3);
    std::cout << "Median: " << medianFinder.findMedian() << std::endl;  // 输出 2
    return 0;
}