#include <iostream>
#include <queue>

int main() {
    std::priority_queue<int> pq;
    pq.push(5);
    pq.push(10);
    pq.push(3);

    std::cout << "隊(duì)首元素（最大值）: " << pq.top() << std::endl;

    pq.pop();

    std::cout << "隊(duì)首元素（最大值）: " << pq.top() << std::endl;

    return 0;
}

#include <iostream>
#include <queue>

struct Compare {
    bool operator()(int a, int b) {
        return a > b;
    }
};

int main() {
    std::priority_queue<int, std::vector<int>, Compare> pq;
    pq.push(5);
    pq.push(10);
    pq.push(3);

    std::cout << "隊(duì)首元素（最小值）: " << pq.top() << std::endl;

    pq.pop();

    std::cout << "隊(duì)首元素（最小值）: " << pq.top() << std::endl;

    return 0;
}

template<typename T>
struct BinaryHeapNode {
    T value;
    BinaryHeapNode<T>* left;
    BinaryHeapNode<T>* right;

    BinaryHeapNode(T val) : value(val), left(nullptr), right(nullptr) {}
};

template<typename T>
void siftUp(BinaryHeapNode<T>* node) {
    while (node!= nullptr && node->parent!= nullptr && node->value > node->parent->value) {
        // 交換節(jié)點(diǎn)和其父節(jié)點(diǎn)的值
        swap(node->value, node->parent->value);
        node = node->parent;
    }
}

template<typename T>
void pushToHeap(BinaryHeapNode<T>* root, T value) {
    // 創(chuàng)建新節(jié)點(diǎn)并插入到堆的末尾
    BinaryHeapNode<T>* newNode = new BinaryHeapNode<T>(value);
    if (root == nullptr) {
        root = newNode;
    } else {
        // 找到合適的位置插入新節(jié)點(diǎn)（這里簡單假設(shè)插入到最后一個(gè)葉子節(jié)點(diǎn)位置）
        BinaryHeapNode<T>* current = root;
        while (current->left!= nullptr && current->right!= nullptr) {
            current = current->left;
        }
        if (current->left == nullptr) {
            current->left = newNode;
        } else {
            current->right = newNode;
        }

        // 對新插入的節(jié)點(diǎn)進(jìn)行上溯操作
        siftUp(newNode);
    }
}

template<typename T>
void siftDown(BinaryHeapNode<T>* node) {
    while (node!= nullptr) {
        BinaryHeapNode<T>* largest = node;
        if (node->left!= nullptr && node->left->value > largest->value) {
            largest = node->left;
        }
        if (node->right!= nullptr && node->right->value > largest->value) {
            largest = node->right;
        }
        if (largest!= node) {
            // 交換節(jié)點(diǎn)和最大子節(jié)點(diǎn)的值
            swap(node->value, largest->value);
            node = largest;
        } else {
            break;
        }
    }
}

template<typename T>
T popFromHeap(BinaryHeapNode<T>* root) {
    if (root == nullptr) {
        throw runtime_error("堆為空");
    }

    T rootValue = root->value;
    // 將堆的最后一個(gè)節(jié)點(diǎn)的值賦給堆頂
    BinaryHeapNode<T>* lastNode = findLastNode(root);
    root->value = lastNode->value;

    // 刪除最后一個(gè)節(jié)點(diǎn)（這里簡單假設(shè)能正確刪除，實(shí)際可能更復(fù)雜）
    delete lastNode;

    // 對新的堆頂節(jié)點(diǎn)進(jìn)行下溯操作
    siftDown(root);

    return rootValue;
}

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

using namespace std;

// 任務(wù)結(jié)構(gòu)體
struct Task {
    string name;
    int priority;

    Task(const string& n, int p) : name(n), priority(p) {}
};

// 自定義比較函數(shù)，按照任務(wù)優(yōu)先級從高到低排序
struct TaskCompare {
    bool operator()(const Task& t1, const Task& t2) {
        return t1.priority < t2.priority;
    }
};

int main() {
    // 創(chuàng)建任務(wù)優(yōu)先隊(duì)列
    priority_queue<Task, vector<Task>, TaskCompare> taskQueue;

    // 添加一些任務(wù)到隊(duì)列
    taskQueue.push(Task("任務(wù)1", 5));
    taskQueue.push(Task("任務(wù)2", 3));
    taskQueue.push(Task("任務(wù)3", 8));

    // 模擬處理器處理任務(wù)
    while (!taskQueue.empty()) {
        Task currentTask = taskQueue.top();
        cout << "正在處理任務(wù): " << currentTask.name << "，優(yōu)先級: " << currentTask.priority << endl;
        taskQueue.pop();
    }

    return 0;
}

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

using namespace std;

// 節(jié)點(diǎn)結(jié)構(gòu)體
struct Node {
    int id;
    vector<Node*> neighbors;
    int distance;

    Node(int i) : id(i), distance(INT_MAX) {}
};

// 自定義比較函數(shù)，按照節(jié)點(diǎn)距離從小到大排序
struct NodeCompare {
    bool operator()(const Node* n1, const Node* n2) {
        return n1->distance > n2->distance;
    }
};

// Dijkstra算法實(shí)現(xiàn)
void dijkstra(Node* source) {
    // 創(chuàng)建優(yōu)先隊(duì)列，按照節(jié)點(diǎn)距離排序
    priority_queue<Node*, vector<Node*>, NodeCompare> pq;

    // 將源點(diǎn)加入隊(duì)列，并設(shè)置其距離為0
    source->distance = 0;
    pq.push(source);

    // 用于記錄已訪問過的節(jié)點(diǎn)
    unordered_map<int, bool> visited;

    while (!pq.empty()) {
        Node* currentNode = pq.top();
        pq.pop();

        // 如果節(jié)點(diǎn)已經(jīng)訪問過，跳過
        if (visited[currentNode->id]) {
            continue;
        }

        // 標(biāo)記當(dāng)前節(jié)點(diǎn)為已訪問
        visited[currentNode->id] = true;

        // 更新當(dāng)前節(jié)點(diǎn)鄰居的距離
        for (Node* neighbor : currentNode->neighbors) {
            int newDistance = currentNode->日前距離 + 1;
            if (newDistance < neighbor->distance) {
                neighbor->distance = newDistance;
                pq.push(neighbor);
            }
        }
    }
}

int main() {
    // 創(chuàng)建一些節(jié)點(diǎn)
    Node* node1 = new Node(1);
    Node* node2 = new Node(2);
    Node* node3 = new Node(3);

    // 構(gòu)建節(jié)點(diǎn)之間的連接關(guān)系
    node1->日前鄰居.push_back(node2);
    node1->日前鄰居.push_back(node3);
    node2->日前鄰居.push_back(node3);

    // 運(yùn)行Dijkstra算法
    dijkstra(node1);

    // 輸出節(jié)點(diǎn)到源點(diǎn)的距離
    cout << "節(jié)點(diǎn)2到源點(diǎn)的距離: " << node2->distance << endl;
    cout << "節(jié)點(diǎn)3到源點(diǎn)的距離: " << node3->distance << endl;

    return 0;
}

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

using namespace std;

// 哈夫曼樹節(jié)點(diǎn)結(jié)構(gòu)體
struct HuffmanNode {
    char data;
    int frequency;
    HuffmanNode* left;
    HuffmanNode* left右;

    HuffmanNode(char d, int f) : data(d), frequency(f), left(nullptr), left右(nullptr) {}
}

// 自定義比較函數(shù)，按照節(jié)點(diǎn)頻率從小到大排序
struct HuffmanNodeCompare {
    bool operator()(const HuffmanNode* n1, const HuffmanNode* n2) {
        return n1->frequency > n2->frequency;
    }
};

// 構(gòu)建哈夫曼樹
HuffmanNode* buildHuffmanTree(const unordered_map<char, int>& frequencyMap) {
    // 創(chuàng)建優(yōu)先隊(duì)列，按照節(jié)點(diǎn)頻率排序
    priority_queue<HuffmanNode*, vector<H夫曼Node*>, HuffmanNodeCompare> pq;

    // 將每個(gè)字符及其頻率對應(yīng)的節(jié)點(diǎn)加入隊(duì)列
    for (const auto& pair : frequencyMap) {
        pq.push(new HuffmanNode(pair.first, pair.second));
    }

    while (pq.size() > 1) {
        // 取出頻率最低的兩個(gè)節(jié)點(diǎn)
        HuffmanNode* leftNode = pq.top();
        pq.pop();
        HuffmanNode* rightNode = pq.top();
        pq.pop();

        // 創(chuàng)建新的父節(jié)點(diǎn)，頻率為兩個(gè)子節(jié)點(diǎn)頻率之和
        HuffmanNode* parentNode = new HuffmanNode('\0', leftNode->frequency + rightNode->frequency);
        parentNode->left = leftNode;
        parentNode->right = rightNode;

        // 將父節(jié)點(diǎn)加入隊(duì)列
        pq.push(parentNode);
    }

    return pq.top();
}

int main() {
    // 假設(shè)這里有個(gè)字符頻率映射表
    unordered_map<char, int> frequencyMap = {
        {'a', 5},
        {'b', 3},
        {'c', 8}
    };

    // 構(gòu)建哈夫曼樹
    HuffmanNode* huffmanTree = buildHuffmanTree(frequencyMap);

    // 這里可以根據(jù)哈夫曼樹進(jìn)一步處理，比如生成編碼等，但為了簡化先不展示啦

    return 0;
}