priority_queue优先级队列

头文件：#include <queue>

定义：priority_queue<Type, Container, Functional>

Type 就是数据类型，Container 就是容器类型（Container必须是用数组实现的容器，比如vector,deque等等，但不能用 list。STL里面默认用的是vector），Functional 就是比较的方式，当需要用自定义的数据类型时才需要传入这三个参数，使用基本数据类型时，只需要传入数据类型，默认是大顶堆。

        // 存储小的值，值越大，优先级越高 升序队列
        priority_queue<int, vector<int>, greater<int>> greater_que;
        // 存储大的值，值越小，优先级越高 降序队列
        priority_queue<int, vector<int>, less<int>> less_que;

greater，less 是std实现的两个仿函数,就是使一个类看上去像一个函数，其实现就是在类中实现一个operator()，这个类就有了类似函数的行为，就是一个仿函数类了。

例子1：基础数据类型

    void MainPriority_queue () {

        vector<int> data = {0, 10, 5, 8, 9, 2, 6, 3};
        // 存储小的值，值越大，优先级越高 升序队列 0 2 3 5 6 8 9 10
        priority_queue<int, vector<int>, greater<int>> greater_que;
        // 存储大的值，值越小，优先级越高 降序队列 10 9 8 6 5 3 2 0
        priority_queue<int, vector<int>, less<int>> less_que;

        for (int i = 0; i < (int) data.size(); ++i) {
            // 大堆顶
            greater_que.push(data[i]);
            // 小堆顶
            less_que.push(data[i]);
        }
        while (!greater_que.empty()) {
            cout << greater_que.top() << " ";
            greater_que.pop();
        }
        cout << endl;
        while (!less_que.empty()) {
            cout << less_que.top() << " ";
            less_que.pop();
        }
        cout << endl;
    }

 

 

 

例子2：自定义数据类型，包括两种排序实现方式，

方法一：重载<

方法二：重新实现仿函数

class Persion {
public:
    int id;
    int age;
    string name;
    // 方法1 直接重载<
    bool operator<(const Persion& b) const
    {
        if (id != b.id) {
            // 大-->小
            return id < b.id;
        }
        if (age != b.age) {
            return age < b.age;
        }
        return name < b.name;
    }
    Persion(int _id, int _age, string _name)
    {
        id = _id;
        age=_age;
        name = _name;
    };
};

struct CmpTest {
    // 方法二 重写仿函数
    bool operator()(const Persion a, const Persion b) const
    {
        if (a.id != b.id) {
            // 小-->大
            return a.id > b.id;
        }
        if (a.age != b.age) {
            return a.age < b.age;
        }
        return a.name < b.name;
    }
};

class Solution {
private:
    vector<Persion> data;
public:
    Solution() {
        data = {
                {5,  20, "zhang"},
                {8,  18, "wei"},
                {8,  18, "ai"},
                {8,  16, "Li"},
                {15, 15, "chen"},
                {15, 30, "chen"},
                {2,  25, "xu"},
                {10, 30, "wang"},
                {7, 30, "wang"},
                {9,  18, "Li"}
        };
    }
    void Fun_Test1() {
        priority_queue<Persion> perLst;

        for (int i = 0; i < (int) data.size(); ++i) {
            perLst.push(data[i]);
        }
        cout << "...show 1.." << endl;
        while (!perLst.empty()) {
            auto v = perLst.top();
            cout << v.id << " " << v.age << " " << v.name << endl;
            perLst.pop();
        }
    }

    void Fun_Test2()
    {
        priority_queue<Persion, vector<Persion>, CmpTest> stulst;
        for (int i = 0; i < (int) data.size(); ++i) {
            stulst.push(data[i]);
        }
        cout << "...show 2.." << endl;
        while (!stulst.empty()) {
            auto v = stulst.top();
            cout << v.id << " " << v.age << " " << v.name << endl;
            stulst.pop();
        }
    }

    void MainPriority_queue () {
        // 存储小的值，值越大，优先级越高 升序队列
        priority_queue<int, vector<int>, greater<int>> greater_que;
        // 存储大的值，值越小，优先级越高 降序队列
        priority_queue<int, vector<int>, less<int>> less_que;
        vector<int> data = {0, 10, 5, 8, 9, 2, 6, 3};
        for (int i = 0; i < (int) data.size(); ++i) {
            // 大堆顶
            greater_que.push(data[i]);
            // 小堆顶
            less_que.push(data[i]);
        }
        while (!greater_que.empty()) {
            cout << greater_que.top() << " ";
            greater_que.pop();
        }
        cout << endl;
        while (!less_que.empty()) {
            cout << less_que.top() << " ";
            less_que.pop();
        }
        cout << endl;
    }
};

 重载符号的时候要注意。const  const不能少。

struct RoomsInfo {
    int start;
    int end;
    RoomsInfo () {}
    RoomsInfo(int s, int e) : start(s), end(e) {}
    // 重载的时候，这两个const一定不能少，一定不能少，不然编译不通过。
    bool operator<(const RoomsInfo& other) const {
        return end > other.end;
    }
};