C++中Queue与Priority Queue的实现

#include <iostream>
#include <queue>
using namespace std;

void test_priority_queue() {
    // 默认是大堆（输出：9 8 7 6 ...）
    priority_queue<int> max_pq;
    max_pq.push(3); 
  	max_pq.push(9); 
  	max_pq.push(1);
    cout << "Max Heap Top: " << max_pq.top() << endl; // 输出 9
}

#include <queue>
#include <functional> // greater 算法的头文件

// 创建小根堆，底层按照大于号比较
std::priority_queue<int, std::vector<int>, std::greater<int>> min_pq;

class Date {
public:
    Date(int year, int month, int day) : _year(year), _month(month), _day(day) {}
    
    // 大根堆需要重载 <
    bool operator<(const Date& d) const {
        if (_year != d._year) return _year < d._year;
        if (_month != d._month) return _month < d._month;
        return _day < d._day;
    }
private:
    int _year, _month, _day;
};

void test_custom_type() {
    std::priority_queue<Date> q;
    q.push(Date(2023, 10, 1));
    q.push(Date(2023, 11, 11)); // 这个会成为堆顶
}

class MyStack {
public:
    void push(int x) {
        q1.empty() ? q2.push(x) : q1.push(x);
    }
    
    int pop() {
        std::queue<int>& emptyQ = q1.empty() ? q1 : q2;
        std::queue<int>& nonEmptyQ = q1.empty() ? q2 : q1;
        
        while (nonEmptyQ.size() > 1) {
            emptyQ.push(nonEmptyQ.front());
            nonEmptyQ.pop();
        }
        int topElement = nonEmptyQ.front();
        nonEmptyQ.pop();
        return topElement;
    }
    
    // top() 和 empty() 逻辑省略...
private:
    std::queue<int> q1, q2;
};

class Solution {
public:
    int findKthLargest(vector<int>& nums, int k) {
        // 将数组中的元素先放入优先级队列中 (O(N) 建堆)
        std::priority_queue<int> p(nums.begin(), nums.end());
        
        // 将前 k-1 个最大的元素删除
        for(int i = 0; i < k - 1; ++i) {
            p.pop();
        }
        return p.top();
    }
};

#pragma once
#include <deque>

namespace bit {
    template<class T, class Container = std::deque<T>>
    class queue {
    public:
        void push(const T& x) { _con.push_back(x); }
        void pop() { _con.pop_front(); }
        const T& back() { return _con.back(); }
        const T& front() { return _con.front(); }
        bool empty() const { return _con.empty(); }
        size_t size() const { return _con.size(); }
    private:
        Container _con;
    };
}

#pragma once
#include <vector>
#include <algorithm> // 包含堆算法
#include <functional>

namespace bit {
    template<class T, class Container = std::vector<T>, class Compare = std::less<T>>
    class priority_queue {
    public:
        priority_queue() {}
        
        template<class InputIterator>
        priority_queue(InputIterator first, InputIterator last) : _con(first, last) {
            // 建堆
            std::make_heap(_con.begin(), _con.end(), comp);
        }

        void push(const T& x) {
            _con.push_back(x);
            std::push_heap(_con.begin(), _con.end(), comp); // 向上调整
        }

        void pop() {
            std::pop_heap(_con.begin(), _con.end(), comp);  // 将堆顶移到末尾，向下调整
            _con.pop_back();                                // 真正删除
        }

        const T& top() const {
            return _con.front();
        }

        bool empty() const {
            return _con.empty();
        }

        size_t size() const {
            return _con.size();
        }

    private:
        Container _con;
        Compare comp; // 比较器对象
    };
}